home *** CD-ROM | disk | FTP | other *** search
/ Champak 130 / Vol 130.iso / games / hummer.swf / scripts / Fmd5.as < prev    next >
Text File  |  2007-01-08  |  169KB  |  3,046 lines
  1. var ┬º\x01┬º = 331;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 331)
  6.    {
  7.       set("\x01",eval("\x01") + 13);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 997)
  12.    {
  13.       set("\x01",eval("\x01") - 406);
  14.       if(┬º┬ºpop())
  15.       {
  16.          set("\x01",eval("\x01") - 76);
  17.       }
  18.       continue;
  19.    }
  20.    if(eval("\x01") != 276)
  21.    {
  22.       if(eval("\x01") == 344)
  23.       {
  24.          set("\x01",eval("\x01") - 68);
  25.          if(┬º┬ºpop())
  26.          {
  27.             set("\x01",eval("\x01") + 175);
  28.          }
  29.       }
  30.       else if(eval("\x01") == 234)
  31.       {
  32.          set("\x01",eval("\x01") + 763);
  33.          ┬º┬ºpush(true);
  34.       }
  35.       else if(eval("\x01") == 451)
  36.       {
  37.          set("\x01",eval("\x01") + 517);
  38.          ┬º┬ºpush(true);
  39.       }
  40.       else
  41.       {
  42.          if(eval("\x01") == 591)
  43.          {
  44.             set("\x01",eval("\x01") - 76);
  45.             break;
  46.          }
  47.          if(eval("\x01") == 515)
  48.          {
  49.             set("\x01",eval("\x01") - 121);
  50.             Fmd5Class.prototype = new MovieClip();
  51.             Fmd5Class.prototype.rol = function(a, n)
  52.             {
  53.                return a << n | a >>> 32 - n;
  54.             };
  55.             Fmd5Class.prototype.FF = function(a, b, c, d, x, s, ac)
  56.             {
  57.                return this.rol(a + (b & c | (~b) & d) + x + ac,s) + b;
  58.             };
  59.             Fmd5Class.prototype.GG = function(a, b, c, d, x, s, ac)
  60.             {
  61.                return this.rol(a + (b & d | c & (~d)) + x + ac,s) + b;
  62.             };
  63.             Fmd5Class.prototype.HH = function(a, b, c, d, x, s, ac)
  64.             {
  65.                return this.rol(a + (b ^ c ^ d) + x + ac,s) + b;
  66.             };
  67.             Fmd5Class.prototype.II = function(a, b, c, d, x, s, ac)
  68.             {
  69.                return this.rol(a + (c ^ (b | ~d)) + x + ac,s) + b;
  70.             };
  71.             Fmd5Class.prototype.transformMD5 = function(buf, offset)
  72.             {
  73.                var _loc6_ = undefined;
  74.                var _loc5_ = undefined;
  75.                var _loc4_ = undefined;
  76.                var _loc3_ = undefined;
  77.                var _loc2_ = this.transformBuffer;
  78.                _loc6_ = this.state[0];
  79.                _loc5_ = this.state[1];
  80.                _loc4_ = this.state[2];
  81.                _loc3_ = this.state[3];
  82.                i = 0;
  83.                while(i < 16)
  84.                {
  85.                   _loc2_[i] = buf[i * 4 + offset] & 255;
  86.                   j = 1;
  87.                   while(j < 4)
  88.                   {
  89.                      _loc2_[i] |= (buf[i * 4 + j + offset] & 255) << j * 8;
  90.                      j++;
  91.                   }
  92.                   i++;
  93.                }
  94.                _loc6_ = this.FF(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[0],7,3614090360);
  95.                _loc3_ = this.FF(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[1],12,3905402710);
  96.                _loc4_ = this.FF(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[2],17,606105819);
  97.                _loc5_ = this.FF(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[3],22,3250441966);
  98.                _loc6_ = this.FF(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[4],7,4118548399);
  99.                _loc3_ = this.FF(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[5],12,1200080426);
  100.                _loc4_ = this.FF(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[6],17,2821735955);
  101.                _loc5_ = this.FF(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[7],22,4249261313);
  102.                _loc6_ = this.FF(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[8],7,1770035416);
  103.                _loc3_ = this.FF(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[9],12,2336552879);
  104.                _loc4_ = this.FF(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[10],17,4294925233);
  105.                _loc5_ = this.FF(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[11],22,2304563134);
  106.                _loc6_ = this.FF(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[12],7,1804603682);
  107.                _loc3_ = this.FF(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[13],12,4254626195);
  108.                _loc4_ = this.FF(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[14],17,2792965006);
  109.                _loc5_ = this.FF(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[15],22,1236535329);
  110.                _loc6_ = this.GG(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[1],5,4129170786);
  111.                _loc3_ = this.GG(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[6],9,3225465664);
  112.                _loc4_ = this.GG(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[11],14,643717713);
  113.                _loc5_ = this.GG(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[0],20,3921069994);
  114.                _loc6_ = this.GG(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[5],5,3593408605);
  115.                _loc3_ = this.GG(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[10],9,38016083);
  116.                _loc4_ = this.GG(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[15],14,3634488961);
  117.                _loc5_ = this.GG(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[4],20,3889429448);
  118.                _loc6_ = this.GG(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[9],5,568446438);
  119.                _loc3_ = this.GG(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[14],9,3275163606);
  120.                _loc4_ = this.GG(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[3],14,4107603335);
  121.                _loc5_ = this.GG(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[8],20,1163531501);
  122.                _loc6_ = this.GG(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[13],5,2850285829);
  123.                _loc3_ = this.GG(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[2],9,4243563512);
  124.                _loc4_ = this.GG(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[7],14,1735328473);
  125.                _loc5_ = this.GG(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[12],20,2368359562);
  126.                _loc6_ = this.HH(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[5],4,4294588738);
  127.                _loc3_ = this.HH(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[8],11,2272392833);
  128.                _loc4_ = this.HH(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[11],16,1839030562);
  129.                _loc5_ = this.HH(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[14],23,4259657740);
  130.                _loc6_ = this.HH(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[1],4,2763975236);
  131.                _loc3_ = this.HH(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[4],11,1272893353);
  132.                _loc4_ = this.HH(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[7],16,4139469664);
  133.                _loc5_ = this.HH(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[10],23,3200236656);
  134.                _loc6_ = this.HH(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[13],4,681279174);
  135.                _loc3_ = this.HH(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[0],11,3936430074);
  136.                _loc4_ = this.HH(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[3],16,3572445317);
  137.                _loc5_ = this.HH(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[6],23,76029189);
  138.                _loc6_ = this.HH(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[9],4,3654602809);
  139.                _loc3_ = this.HH(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[12],11,3873151461);
  140.                _loc4_ = this.HH(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[15],16,530742520);
  141.                _loc5_ = this.HH(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[2],23,3299628645);
  142.                _loc6_ = this.II(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[0],6,4096336452);
  143.                _loc3_ = this.II(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[7],10,1126891415);
  144.                _loc4_ = this.II(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[14],15,2878612391);
  145.                _loc5_ = this.II(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[5],21,4237533241);
  146.                _loc6_ = this.II(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[12],6,1700485571);
  147.                _loc3_ = this.II(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[3],10,2399980690);
  148.                _loc4_ = this.II(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[10],15,4293915773);
  149.                _loc5_ = this.II(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[1],21,2240044497);
  150.                _loc6_ = this.II(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[8],6,1873313359);
  151.                _loc3_ = this.II(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[15],10,4264355552);
  152.                _loc4_ = this.II(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[6],15,2734768916);
  153.                _loc5_ = this.II(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[13],21,1309151649);
  154.                _loc6_ = this.II(_loc6_,_loc5_,_loc4_,_loc3_,_loc2_[4],6,4149444226);
  155.                _loc3_ = this.II(_loc3_,_loc6_,_loc5_,_loc4_,_loc2_[11],10,3174756917);
  156.                _loc4_ = this.II(_loc4_,_loc3_,_loc6_,_loc5_,_loc2_[2],15,718787259);
  157.                _loc5_ = this.II(_loc5_,_loc4_,_loc3_,_loc6_,_loc2_[9],21,3951481745);
  158.                this.state[0] += _loc6_;
  159.                this.state[1] += _loc5_;
  160.                this.state[2] += _loc4_;
  161.                this.state[3] += _loc3_;
  162.             };
  163.             Fmd5Class.prototype.MD5Init = function()
  164.             {
  165.                this.count0 = this.count1 = 0;
  166.                this.state[0] = 1732584193;
  167.                this.state[1] = 4023233417;
  168.                this.state[2] = 2562383102;
  169.                this.state[3] = 271733878;
  170.                i = 0;
  171.                while(i < this.digestBits.length)
  172.                {
  173.                   this.digestBits[i] = 0;
  174.                   i++;
  175.                }
  176.             };
  177.             Fmd5Class.prototype.MD5Update = function(b)
  178.             {
  179.                var _loc2_ = this.count0 >>> 3 & 63;
  180.                if(4294967288 <= this.count0)
  181.                {
  182.                   this.count1 = this.count1 + 1;
  183.                   this.count0 -= 4294967296;
  184.                }
  185.                this.count0 += 8;
  186.                this.buffer[_loc2_] = b & 255;
  187.                trace(_loc2_);
  188.                if(_loc2_ >= 63)
  189.                {
  190.                   this.transformMD5(this.buffer,0);
  191.                }
  192.             };
  193.             Fmd5Class.prototype.MD5Final = function()
  194.             {
  195.                var _loc4_ = new Array(8);
  196.                var _loc2_ = undefined;
  197.                var _loc3_ = undefined;
  198.                _loc2_ = 0;
  199.                while(_loc2_ < 4)
  200.                {
  201.                   _loc4_[_loc2_] = this.count0 >>> _loc2_ * 8 & 255;
  202.                   _loc4_[_loc2_ + 4] = this.count1 >>> _loc2_ * 8 & 255;
  203.                   _loc2_ = _loc2_ + 1;
  204.                }
  205.                var _loc6_ = this.count0 >>> 3 & 63;
  206.                var _loc5_ = _loc6_ >= 56 ? 120 - _loc6_ : 56 - _loc6_;
  207.                this.MD5Update(128);
  208.                _loc2_ = 1;
  209.                while(_loc2_ < _loc5_)
  210.                {
  211.                   this.MD5Update(0);
  212.                   _loc2_ = _loc2_ + 1;
  213.                }
  214.                _loc2_ = 0;
  215.                while(_loc2_ < 8)
  216.                {
  217.                   this.MD5Update(_loc4_[_loc2_]);
  218.                   _loc2_ = _loc2_ + 1;
  219.                }
  220.                _loc2_ = 0;
  221.                while(_loc2_ < 4)
  222.                {
  223.                   _loc3_ = 0;
  224.                   while(_loc3_ < 4)
  225.                   {
  226.                      this.digestBits[_loc2_ * 4 + _loc3_] = this.state[_loc2_] >>> _loc3_ * 8 & 255;
  227.                      _loc3_ = _loc3_ + 1;
  228.                   }
  229.                   _loc2_ = _loc2_ + 1;
  230.                }
  231.             };
  232.             Fmd5Class.prototype.byteToStr = function(bt)
  233.             {
  234.                var _loc1_ = "0123456789abcdef";
  235.                var _loc2_ = _loc1_.charAt(bt >> 4) + _loc1_.charAt(bt & 15);
  236.                return _loc2_;
  237.             };
  238.             Fmd5Class.prototype.md5 = function(m)
  239.             {
  240.                var _loc4_ = "";
  241.                this.MD5Init();
  242.                var _loc2_ = 0;
  243.                while(_loc2_ < m.length)
  244.                {
  245.                   this.MD5Update(m.charCodeAt(_loc2_));
  246.                   _loc2_ = _loc2_ + 1;
  247.                }
  248.                this.MD5Final();
  249.                _loc2_ = 0;
  250.                while(_loc2_ < 16)
  251.                {
  252.                   _loc4_ += this.byteToStr(this.digestBits[_loc2_]);
  253.                   _loc2_ = _loc2_ + 1;
  254.                }
  255.                return _loc4_;
  256.             };
  257.             Fmd5Class.prototype.verifytext = function(d, m)
  258.             {
  259.                return this.md5(m) == d;
  260.             };
  261.             Fmd5Class.prototype.makeSig = function(input)
  262.             {
  263.                return this.md5(input);
  264.             };
  265.             Object.registerClass("Fmd5",Fmd5Class);
  266.             break;
  267.          }
  268.          if(eval("\x01") == 402)
  269.          {
  270.             set("\x01",eval("\x01") - 168);
  271.             break;
  272.          }
  273.          if(eval("\x01") != 968)
  274.          {
  275.             break;
  276.          }
  277.          set("\x01",eval("\x01") - 566);
  278.          if(┬º┬ºpop())
  279.          {
  280.             set("\x01",eval("\x01") - 168);
  281.          }
  282.       }
  283.       continue;
  284.    }
  285.    set("\x01",eval("\x01") + 175);
  286.    loop1:
  287.    while(true)
  288.    {
  289.       set(┬º┬ºpop(),┬º┬ºpop() - 351);
  290.       ┬º┬ºpush(true);
  291.       while(eval("\x01") != 659)
  292.       {
  293.          if(eval("\x01") == 259)
  294.          {
  295.             set("\x01",eval("\x01") + 285);
  296.             break loop0;
  297.          }
  298.          if(eval("\x01") == 63)
  299.          {
  300.             set("\x01",eval("\x01") + 559);
  301.             while(true)
  302.             {
  303.                var _loc4_ = ┬º┬ºpop();
  304.                if(_loc4_ >= _loc5_[┬º┬ºconstant(11)][┬º┬ºconstant(12)])
  305.                {
  306.                   break;
  307.                }
  308.                var _loc11_ = _loc5_[┬º┬ºconstant(11)][_loc8_];
  309.                var _loc10_ = _loc5_[┬º┬ºconstant(11)][_loc4_];
  310.                var _loc9_ = _loc10_[┬º┬ºconstant(10)](_loc11_);
  311.                var _loc8_ = _loc4_;
  312.                _loc3_[_loc2_] = new eval(┬º┬ºconstant(13))[┬º┬ºconstant(14)]();
  313.                _loc7_[_loc2_] = new ┬º\┬º\┬ºconstant(15)┬º();
  314.                _loc3_[_loc2_] = _loc9_[┬º┬ºconstant(16)]();
  315.                if(!_loc1_[┬º┬ºconstant(17)](_loc6_,_loc5_,_loc3_[_loc2_],_loc12_))
  316.                {
  317.                   return false;
  318.                }
  319.                _loc7_[_loc2_] = _loc1_.transformBuffer();
  320.                var _loc2_ = _loc2_ + 1;
  321.             }
  322.             var _loc15_ = _loc1_.MD5Init(_loc3_,_loc7_,_loc2_);
  323.             var _loc14_ = _loc15_.length;
  324.             var _loc16_ = _loc15_.MD5Update;
  325.             if(_loc14_.MD5Final(_loc12_) < 0)
  326.             {
  327.                _loc14_.byteToStr();
  328.             }
  329.             var _loc13_ = new state();
  330.             _loc13_.length = _loc14_;
  331.             _loc13_.MD5Update = _loc16_;
  332.             return _loc13_;
  333.          }
  334.          if(eval("\x01") == 103)
  335.          {
  336.             set("\x01",eval("\x01") + 836);
  337.             if(┬º┬ºpop())
  338.             {
  339.                set("\x01",eval("\x01") - 160);
  340.             }
  341.             continue;
  342.          }
  343.          if(eval("\x01") == 180)
  344.          {
  345.             set("\x01",eval("\x01") + 336);
  346.             nextFrame();
  347.             toggleHighQuality();
  348.             toggleHighQuality();
  349.             ┬º┬ºpop()[┬º┬ºpop()] = function()
  350.             {
  351.                var _loc3_ = rol.FF(this.MovieClip() * 1000) / 1000;
  352.                var _loc2_ = rol.FF(this.GG() * 1000) / 1000;
  353.                return "HH" + _loc3_ + "II" + _loc2_ + "transformMD5";
  354.             };
  355.             _loc2_.i = function(x, y)
  356.             {
  357.                this.buffer(x,y);
  358.             };
  359.             _loc2_.j = function()
  360.             {
  361.                return new count1.Array(this.MovieClip(),this.GG());
  362.             };
  363.             _loc2_.MD5Init = function(v)
  364.             {
  365.                return this.MovieClip() == v.MovieClip() && this.GG() == v.GG();
  366.             };
  367.             _loc2_.length = function(v)
  368.             {
  369.                this.MD5Update += v.MD5Update;
  370.                this.MD5Final += v.MD5Final;
  371.             };
  372.             _loc2_.byteToStr = function(v)
  373.             {
  374.                return new count1.Array(this.MovieClip() + v.MovieClip(),this.GG() + v.GG());
  375.             };
  376.             _loc2_["0123456789abcdef"] = function(v)
  377.             {
  378.                this.MD5Update -= v.MD5Update;
  379.                this.MD5Final -= v.MD5Final;
  380.             };
  381.             _loc2_.charAt = function(v)
  382.             {
  383.                return new count1.Array(this.MovieClip() - v.MovieClip(),this.GG() - v.GG());
  384.             };
  385.             _loc2_.md5 = function()
  386.             {
  387.                this.digestBits(- this.MovieClip());
  388.                this.Fmd5Class(- this.GG());
  389.             };
  390.             _loc2_[""] = function()
  391.             {
  392.                return new count1.Array(- this.MovieClip(),- this.GG());
  393.             };
  394.             _loc2_.charCodeAt = function(s)
  395.             {
  396.                this.MD5Update *= s;
  397.                this.MD5Final *= s;
  398.             };
  399.             _loc2_.verifytext = function(s)
  400.             {
  401.                return new count1.Array(this.MovieClip() * s,this.GG() * s);
  402.             };
  403.             _loc2_.makeSig = function()
  404.             {
  405.                return rol.Fmd5(this.MovieClip() * this.MovieClip() + this.GG() * this.GG());
  406.             };
  407.             _loc2_.Object = function(len)
  408.             {
  409.                var _loc2_ = this.makeSig();
  410.                !_loc2_ ? this.digestBits(len) : this.charCodeAt(len / _loc2_);
  411.             };
  412.             _loc2_.registerClass = function()
  413.             {
  414.                return count1[┬º┬ºconstant(33)][┬º┬ºconstant(34)](this.GG(),this.MovieClip());
  415.             };
  416.             _loc2_[┬º┬ºconstant(35)] = function(ang)
  417.             {
  418.                var _loc2_ = this.makeSig();
  419.                this.digestBits(_loc2_ * count1[┬º┬ºconstant(33)][┬º┬ºconstant(36)](ang));
  420.                this.Fmd5Class(_loc2_ * count1[┬º┬ºconstant(33)][┬º┬ºconstant(37)](ang));
  421.             };
  422.             _loc2_[┬º┬ºconstant(38)] = function(ang)
  423.             {
  424.                var _loc3_ = count1[┬º┬ºconstant(33)][┬º┬ºconstant(36)](ang);
  425.                var _loc2_ = count1[┬º┬ºconstant(33)][┬º┬ºconstant(37)](ang);
  426.                var _loc5_ = this.MovieClip() * _loc3_ - this.GG() * _loc2_;
  427.                var _loc4_ = this.MovieClip() * _loc2_ + this.GG() * _loc3_;
  428.                this.digestBits(_loc5_);
  429.                this.Fmd5Class(_loc4_);
  430.             };
  431.             _loc2_[┬º┬ºconstant(39)] = function(ang)
  432.             {
  433.                var _loc2_ = new count1.Array(this.MovieClip(),this.GG());
  434.                _loc2_[┬º┬ºconstant(38)](ang);
  435.                return _loc2_;
  436.             };
  437.             _loc2_[┬º┬ºconstant(40)] = function(v)
  438.             {
  439.                return this.MovieClip() * v.MovieClip() + this.GG() * v.GG();
  440.             };
  441.             _loc2_[┬º┬ºconstant(41)] = function()
  442.             {
  443.                return new count1.Array(- this.GG(),this.MovieClip());
  444.             };
  445.             _loc2_[┬º┬ºconstant(42)] = function(v)
  446.             {
  447.                return this[┬º┬ºconstant(40)](v) == 0;
  448.             };
  449.             _loc2_[┬º┬ºconstant(43)] = function(v)
  450.             {
  451.                return this[┬º┬ºconstant(42)](v);
  452.             };
  453.             _loc2_[┬º┬ºconstant(44)] = function(v)
  454.             {
  455.                var _loc3_ = this[┬º┬ºconstant(40)](v);
  456.                var _loc2_ = _loc3_ / (this.makeSig() * v.makeSig());
  457.                return count1[┬º┬ºconstant(33)][┬º┬ºconstant(45)](_loc2_);
  458.             };
  459.             _loc2_.MovieClip = function()
  460.             {
  461.                return this[┬º┬ºconstant(46)];
  462.             };
  463.             _loc2_.digestBits = function(x)
  464.             {
  465.                this[┬º┬ºconstant(46)] = x;
  466.                return this.MovieClip();
  467.             };
  468.             _loc2_.GG = function()
  469.             {
  470.                return this[┬º┬ºconstant(47)];
  471.             };
  472.             _loc2_.Fmd5Class = function(y)
  473.             {
  474.                this[┬º┬ºconstant(47)] = y;
  475.                return this.GG();
  476.             };
  477.             _loc2_[┬º┬ºconstant(48)] = function()
  478.             {
  479.                return this.makeSig();
  480.             };
  481.             _loc2_[┬º┬ºconstant(49)] = function(len)
  482.             {
  483.                this.Object(len);
  484.                return this[┬º┬ºconstant(48)]();
  485.             };
  486.             _loc2_[┬º┬ºconstant(50)] = function()
  487.             {
  488.                return this.registerClass();
  489.             };
  490.             _loc2_[┬º┬ºconstant(51)] = function(ang)
  491.             {
  492.                this[┬º┬ºconstant(35)](ang);
  493.                return this[┬º┬ºconstant(50)]();
  494.             };
  495.             ┬º┬ºconstant(55)(count1.Array.transformBuffer,null,1);
  496.             ┬º┬ºpush(_loc2_[┬º┬ºconstant(53)](┬º┬ºconstant(52),_loc2_[┬º┬ºconstant(50)],_loc2_[┬º┬ºconstant(51)]));
  497.             ┬º┬ºpush(_loc2_[┬º┬ºconstant(53)](┬º┬ºconstant(54),_loc2_[┬º┬ºconstant(48)],_loc2_[┬º┬ºconstant(49)]));
  498.             ┬º┬ºpush(_loc2_[┬º┬ºconstant(53)]("MD5Update",_loc2_.MovieClip,_loc2_.digestBits));
  499.             ┬º┬ºpush(_loc2_[┬º┬ºconstant(53)]("MD5Final",_loc2_.GG,_loc2_.Fmd5Class));
  500.             break loop0;
  501.          }
  502.          if(eval("\x01") == 915)
  503.          {
  504.             set("\x01",eval("\x01") - 656);
  505.             if(┬º┬ºpop())
  506.             {
  507.                set("\x01",eval("\x01") + 285);
  508.             }
  509.             continue;
  510.          }
  511.          if(eval("\x01") == 957)
  512.          {
  513.             set("\x01",eval("\x01") - 42);
  514.             ┬º┬ºpush(true);
  515.             continue;
  516.          }
  517.          if(eval("\x01") == 91)
  518.          {
  519.             set("\x01",eval("\x01") - 28);
  520.             if(┬º┬ºpop())
  521.             {
  522.                set("\x01",eval("\x01") + 559);
  523.             }
  524.             continue;
  525.          }
  526.          if(eval("\x01") == 219)
  527.          {
  528.             set("\x01",eval("\x01") - 39);
  529.             if(┬º┬ºpop())
  530.             {
  531.                set("\x01",eval("\x01") + 336);
  532.             }
  533.             continue;
  534.          }
  535.          if(eval("\x01") == 39)
  536.          {
  537.             set("\x01",eval("\x01") + 918);
  538.             while(true)
  539.             {
  540.                if(┬º┬ºpop() == ┬º┬ºpop())
  541.                {
  542.                   set("\x01",eval("\x01") + 138);
  543.                   ┬º┬ºpush(true);
  544.                   continue;
  545.                }
  546.                if(eval("\x01") == 945)
  547.                {
  548.                   set("\x01",eval("\x01") - 652);
  549.                   ┬º┬ºpush(true);
  550.                   continue;
  551.                }
  552.                if(eval("\x01") == 293)
  553.                {
  554.                   set("\x01",eval("\x01") + 50);
  555.                   if(┬º┬ºpop())
  556.                   {
  557.                      set("\x01",eval("\x01") + 614);
  558.                   }
  559.                   continue;
  560.                }
  561.                if(eval("\x01") == 739)
  562.                {
  563.                   set("\x01",eval("\x01") - 720);
  564.                   if(┬º┬ºpop())
  565.                   {
  566.                      set("\x01",eval("\x01") + 926);
  567.                   }
  568.                   continue;
  569.                }
  570.                if(eval("\x01") == 19)
  571.                {
  572.                   set("\x01",eval("\x01") + 926);
  573.                   ┬º┬ºpush(┬º┬ºpop() === ┬º┬ºpop() >>> (┬º┬ºpop() >> (┬º┬ºpop() << ┬º┬ºpop())));
  574.                   break loop0;
  575.                }
  576.                if(eval("\x01") == 343)
  577.                {
  578.                   set("\x01",eval("\x01") + 614);
  579.                   break loop0;
  580.                }
  581.                if(eval("\x01") != 962)
  582.                {
  583.                   if(eval("\x01") == 957)
  584.                   {
  585.                      set("\x01",eval("\x01") - 705);
  586.                      ┬º┬ºpush(true);
  587.                   }
  588.                   else
  589.                   {
  590.                      if(eval("\x01") != 252)
  591.                      {
  592.                         if(eval("\x01") == 624)
  593.                         {
  594.                            set("\x01",eval("\x01") - 223);
  595.                            if(!_global.utils)
  596.                            {
  597.                               _global.utils = new Object();
  598.                            }
  599.                            ┬º┬ºpop();
  600.                            if(!_global.utils.FSound)
  601.                            {
  602.                               utils.FSound extends MovieClip;
  603.                               _loc2_ = utils.FSound = function()
  604.                               {
  605.                                  super();
  606.                                  this.valume = 50;
  607.                                  this.indexSound = 0;
  608.                               }.prototype;
  609.                               _loc2_.setValume = function(val)
  610.                               {
  611.                                  this.valume = val;
  612.                                  for(var _loc3_ in this)
  613.                                  {
  614.                                     if(this[_loc3_].loop != true)
  615.                                     {
  616.                                        this[_loc3_].sn.setVolume(val);
  617.                                     }
  618.                                  }
  619.                               };
  620.                               _loc2_.stopAllSound = function()
  621.                               {
  622.                                  for(var _loc2_ in this)
  623.                                  {
  624.                                     trace(_loc2_ + " >>> deleted");
  625.                                     this[_loc2_].sn.stop();
  626.                                     this[_loc2_].removeMovieClip();
  627.                                  }
  628.                               };
  629.                               _loc2_.playSound2 = function(sound, pan, loop, valumeT)
  630.                               {
  631.                                  pan = pan != undefined ? pan : 0;
  632.                                  pan = pan <= 100 ? pan : 100;
  633.                                  pan = pan >= -100 ? pan : -100;
  634.                                  if(this.valume > 0 && this[sound] == undefined)
  635.                                  {
  636.                                     this.indexSound = this.indexSound + 1;
  637.                                     var mc = this.createEmptyMovieClip(sound,this.getNextHighestDepth());
  638.                                     mc.sn = new Sound(mc);
  639.                                     mc.sn.attachSound(sound);
  640.                                     mc.sn.setVolume(this.valume);
  641.                                     mc.sn.setPan(pan);
  642.                                     mc.sn._parent = this;
  643.                                     mc.sn._parent2 = mc;
  644.                                     mc.loop = loop;
  645.                                     mc.sn.mc = mc;
  646.                                     mc.sn.indexSound = this.indexSound;
  647.                                     if(loop == true)
  648.                                     {
  649.                                        mc.sn.start(0,1000000);
  650.                                     }
  651.                                     else
  652.                                     {
  653.                                        mc.sn.onSoundComplete = function()
  654.                                        {
  655.                                           this.mc.removeMovieClip();
  656.                                        };
  657.                                        mc.sn.start();
  658.                                     }
  659.                                     if(this["mc" + (this.indexSound - 100)].loop != true)
  660.                                     {
  661.                                        delete this["mc" + (this.indexSound - 100)].sn;
  662.                                        this["mc" + (this.indexSound - 100)].removeMovieClip();
  663.                                     }
  664.                                     return mc.sn;
  665.                                  }
  666.                               };
  667.                               _loc2_.playSound = function(sound, pan, loop, valumeT)
  668.                               {
  669.                                  pan = pan != undefined ? pan : 0;
  670.                                  pan = pan <= 100 ? pan : 100;
  671.                                  pan = pan >= -100 ? pan : -100;
  672.                                  if(this.valume > 0)
  673.                                  {
  674.                                     this.indexSound = this.indexSound + 1;
  675.                                     var mc = this.createEmptyMovieClip("mc" + this.indexSound,this.getNextHighestDepth());
  676.                                     mc.sn = new Sound(mc);
  677.                                     mc.sn.attachSound(sound);
  678.                                     if(valumeT)
  679.                                     {
  680.                                        mc.sn.setVolume(this.valume * valumeT);
  681.                                     }
  682.                                     else
  683.                                     {
  684.                                        mc.sn.setVolume(this.valume);
  685.                                     }
  686.                                     mc.sn.setPan(pan);
  687.                                     mc.sn._parent = this;
  688.                                     mc.sn._parent2 = mc;
  689.                                     mc.loop = loop;
  690.                                     mc.sn.mc = mc;
  691.                                     mc.sn.indexSound = this.indexSound;
  692.                                     if(loop == true)
  693.                                     {
  694.                                        mc.sn.start(0,1000000);
  695.                                     }
  696.                                     else
  697.                                     {
  698.                                        mc.sn.onSoundComplete = function()
  699.                                        {
  700.                                           this.mc.removeMovieClip();
  701.                                        };
  702.                                        mc.sn.start();
  703.                                     }
  704.                                     if(this["mc" + (this.indexSound - 100)].loop != true)
  705.                                     {
  706.                                        delete this["mc" + (this.indexSound - 100)].sn;
  707.                                        this["mc" + (this.indexSound - 100)].removeMovieClip();
  708.                                     }
  709.                                     return mc.sn;
  710.                                  }
  711.                               };
  712.                               ┬º┬ºpush(ASSetPropFlags(utils.FSound.prototype,null,1));
  713.                            }
  714.                            ┬º┬ºpop();
  715.                            break loop0;
  716.                         }
  717.                         break loop0;
  718.                      }
  719.                      set("\x01",eval("\x01") + 710);
  720.                      if(┬º┬ºpop())
  721.                      {
  722.                         set("\x01",eval("\x01") - 338);
  723.                      }
  724.                   }
  725.                   continue;
  726.                }
  727.                set("\x01",eval("\x01") - 338);
  728.                while(true)
  729.                {
  730.                   if(eval(┬º┬ºpop()) == 528)
  731.                   {
  732.                      set("\x01",eval("\x01") + 33);
  733.                      ┬º┬ºpush(true);
  734.                   }
  735.                   else if(eval("\x01") == 243)
  736.                   {
  737.                      set("\x01",eval("\x01") + 78);
  738.                      ┬º┬ºpush(true);
  739.                   }
  740.                   else if(eval("\x01") == 592)
  741.                   {
  742.                      set("\x01",eval("\x01") + 10);
  743.                      ┬º┬ºpush(true);
  744.                   }
  745.                   else
  746.                   {
  747.                      if(eval("\x01") == 84)
  748.                      {
  749.                         set("\x01",eval("\x01") + 158);
  750.                         if(!_global.engine)
  751.                         {
  752.                            _global.engine = new Object();
  753.                         }
  754.                         ┬º┬ºpop();
  755.                         if(!_global.engine.Screen)
  756.                         {
  757.                            engine.Screen extends MovieClip;
  758.                            _loc2_ = engine.Screen = function()
  759.                            {
  760.                               super();
  761.                               this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  762.                               this.gameArea = this.level4.level3.level2.level1;
  763.                               this.cameraSpeed = 100;
  764.                               this.poleRot = 0;
  765.                               this.scale = 400;
  766.                            }.prototype;
  767.                            _loc2_.setGoal = function(g, p)
  768.                            {
  769.                               this.goal = g;
  770.                               this.preview = p;
  771.                            };
  772.                            _loc2_.setCameraSpeed = function(val)
  773.                            {
  774.                               this.cameraSpeed = val;
  775.                            };
  776.                            _loc2_.loadBg = function(url, compliteFunc, progressFunc, goal)
  777.                            {
  778.                               if(!this.gameArea.trassa)
  779.                               {
  780.                                  this.gameArea.createEmptyMovieClip("trassa",this.gameArea.getNextHighestDepth());
  781.                               }
  782.                               var _loc2_ = new Object();
  783.                               var _loc3_ = new MovieClipLoader();
  784.                               _loc2_.parent = this;
  785.                               _loc2_.onLoadInit = function(g)
  786.                               {
  787.                                  trace("screen loading complite " + compliteFunc);
  788.                                  this = this.parent;
  789.                                  g._xscale = this.scale;
  790.                                  g._yscale = this.scale;
  791.                                  compliteFunc.apply(goal,[true]);
  792.                               };
  793.                               _loc2_.onLoadError = function(g)
  794.                               {
  795.                                  trace("screen loading error " + compliteFunc);
  796.                                  this = this.parent;
  797.                                  compliteFunc.apply(goal,[false]);
  798.                               };
  799.                               _loc2_.onLoadProgress = function(target, bytesLoaded, bytesTotal)
  800.                               {
  801.                                  this = this.parent;
  802.                                  progressFunc.apply(goal,[bytesLoaded,bytesTotal]);
  803.                               };
  804.                               _loc3_.addListener(_loc2_);
  805.                               _loc3_.loadClip(url,this.gameArea.trassa);
  806.                               trace(">>>>>>>> url " + url);
  807.                            };
  808.                            _loc2_.setSize = function(x, y, dx, dy)
  809.                            {
  810.                               this._x = x;
  811.                               this._y = y;
  812.                               this.level4._x = dx / 2;
  813.                               this.level4._y = dy / 2;
  814.                               this.level4.level3._yscale = 60;
  815.                               var _loc3_ = this._parent.getNextHighestDepth();
  816.                               var _loc2_ = this._parent.createEmptyMovieClip("mask " + _loc3_,_loc3_);
  817.                               _loc2_.beginFill(0,100);
  818.                               _loc2_.moveTo(0,0);
  819.                               _loc2_.lineTo(0,dy);
  820.                               _loc2_.lineTo(dx,dy);
  821.                               _loc2_.lineTo(dx,0);
  822.                               _loc2_._x = x;
  823.                               _loc2_._y = y;
  824.                               _loc2_.endFill();
  825.                               this.setMask(_loc2_);
  826.                            };
  827.                            _loc2_.getAngel = function(angel)
  828.                            {
  829.                               this.arrowMc._rotation = angel;
  830.                               return this.arrowMc._rotation;
  831.                            };
  832.                            addr2513:
  833.                            _loc2_.updateLevel1 = function()
  834.                            {
  835.                               var _loc2_ = new Object();
  836.                               _loc2_.x = this.goal.getX();
  837.                               _loc2_.y = this.goal.getY();
  838.                               this.gameArea.trassa.localToGlobal(_loc2_);
  839.                               this.gameArea.globalToLocal(_loc2_);
  840.                               this.Fmd5Class[┬º┬ºconstant(39)] -= (_loc2_[┬º┬ºconstant(51)] + this.Fmd5Class[┬º┬ºconstant(39)]) / 5;
  841.                               this.Fmd5Class[┬º┬ºconstant(40)] -= (_loc2_[┬º┬ºconstant(53)] + this.Fmd5Class[┬º┬ºconstant(40)]) / 5;
  842.                            };
  843.                            _loc2_[┬º┬ºconstant(57)] = function()
  844.                            {
  845.                               var _loc4_ = this.prototype.MovieClip.rol[┬º┬ºconstant(49)];
  846.                               var _loc3_ = this.MD5Init[┬º┬ºconstant(58)]();
  847.                               var _loc6_ = _loc3_ - _loc4_;
  848.                               var _loc5_ = _loc4_ - _loc3_;
  849.                               this.HH += this[┬º┬ºconstant(48)](- _loc3_ - this.HH) / _root[┬º┬ºconstant(59)][┬º┬ºconstant(60)].GG;
  850.                               this.prototype.MovieClip.rol[┬º┬ºconstant(49)] = this.HH - 90;
  851.                               this.length.length[┬º┬ºconstant(49)] = _loc4_;
  852.                            };
  853.                            addr2633:
  854.                            _loc2_[┬º┬ºconstant(61)] = function()
  855.                            {
  856.                               var _loc2_ = 100 - 50 * (this.MD5Init[┬º┬ºconstant(62)] / this.MD5Init[┬º┬ºconstant(63)]);
  857.                               this.prototype.verifytext -= (this.prototype.verifytext - _loc2_) / 50;
  858.                               this.prototype.makeSig -= (this.prototype.makeSig - _loc2_) / 50;
  859.                               this[┬º┬ºconstant(64)] = this.prototype.verifytext;
  860.                            };
  861.                            _loc2_[┬º┬ºconstant(65)] = function()
  862.                            {
  863.                               this[┬º┬ºconstant(50)]();
  864.                               this[┬º┬ºconstant(57)]();
  865.                               this[┬º┬ºconstant(61)]();
  866.                            };
  867.                            _loc2_[┬º┬ºconstant(66)] = function()
  868.                            {
  869.                               var _loc2_ = this.transformBuffer();
  870.                               var _loc3_ = this[┬º┬ºconstant(69)](┬º┬ºconstant(68),┬º┬ºconstant(67) + _loc2_,this.transformBuffer());
  871.                               return _loc3_;
  872.                            };
  873.                            _loc2_[┬º┬ºconstant(70)] = function(g, url, compliteFunc, progressFunc, goal)
  874.                            {
  875.                               var _loc2_ = new state();
  876.                               var _loc3_ = new ┬º0123456789abcdef┬º();
  877.                               _loc2_.charAt = this;
  878.                               _loc2_.md5 = function(g)
  879.                               {
  880.                                  trace(┬º┬ºconstant(71) + charCodeAt);
  881.                                  this = this.charAt;
  882.                                  charCodeAt.Fmd5(MD5Init,[true]);
  883.                               };
  884.                               _loc2_.Object = function(g)
  885.                               {
  886.                                  trace(┬º┬ºconstant(72) + charCodeAt);
  887.                                  this = this.charAt;
  888.                                  charCodeAt.Fmd5(MD5Init,[false]);
  889.                               };
  890.                               _loc2_[┬º┬ºconstant(33)] = function(target, bytesLoaded, bytesTotal)
  891.                               {
  892.                                  this = this.charAt;
  893.                                  eval(┬º┬ºconstant(34)).Fmd5(MD5Init,[bytesLoaded,bytesTotal]);
  894.                               };
  895.                               _loc3_[┬º┬ºconstant(35)](_loc2_);
  896.                               _loc3_[┬º┬ºconstant(36)](url,g);
  897.                               trace(┬º┬ºconstant(37) + url);
  898.                            };
  899.                            _loc2_[┬º┬ºconstant(73)] = function(num)
  900.                            {
  901.                               return num - 360 * eval(┬º┬ºconstant(74))[┬º┬ºconstant(75)](num / 360);
  902.                            };
  903.                            _loc2_[┬º┬ºconstant(76)] = function(g1, p)
  904.                            {
  905.                               var _loc2_ = new state();
  906.                               _loc2_[┬º┬ºconstant(51)] = p[┬º┬ºconstant(52)]();
  907.                               _loc2_[┬º┬ºconstant(53)] = p[┬º┬ºconstant(54)]();
  908.                               this.Fmd5Class.byteToStr[┬º┬ºconstant(55)](_loc2_);
  909.                               this[┬º┬ºconstant(56)](_loc2_);
  910.                               g1[┬º┬ºconstant(39)] = _loc2_[┬º┬ºconstant(51)];
  911.                               g1[┬º┬ºconstant(40)] = _loc2_[┬º┬ºconstant(53)];
  912.                               var _loc5_ = eval(┬º┬ºconstant(74))[┬º┬ºconstant(77)](this[┬º┬ºconstant(73)](p[┬º┬ºconstant(58)]() + this.HH) / 5);
  913.                               g1[┬º┬ºconstant(78)](_loc5_);
  914.                               g1[┬º┬ºconstant(79)](eval(┬º┬ºconstant(74))[┬º┬ºconstant(77)](g1[┬º┬ºconstant(40)] * 1000));
  915.                               g1.verifytext = this[┬º┬ºconstant(64)];
  916.                               g1.makeSig = this[┬º┬ºconstant(64)];
  917.                            };
  918.                            ┬º┬ºpush(┬º┬ºconstant(80)(count1.Array.i,null,1));
  919.                         }
  920.                         ┬º┬ºpop();
  921.                         break loop0;
  922.                      }
  923.                      if(eval("\x01") == 321)
  924.                      {
  925.                         set("\x01",eval("\x01") + 569);
  926.                         if(┬º┬ºpop())
  927.                         {
  928.                            set("\x01",eval("\x01") - 831);
  929.                         }
  930.                         addr2828:
  931.                         while(true)
  932.                         {
  933.                            if(eval("\x01") == 683)
  934.                            {
  935.                               set("\x01",eval("\x01") - 598);
  936.                               ┬º┬ºpush(true);
  937.                            }
  938.                            else if(eval("\x01") == 961)
  939.                            {
  940.                               set("\x01",eval("\x01") - 746);
  941.                               if(┬º┬ºpop())
  942.                               {
  943.                                  set("\x01",eval("\x01") + 454);
  944.                               }
  945.                            }
  946.                            else if(eval("\x01") == 85)
  947.                            {
  948.                               set("\x01",eval("\x01") + 20);
  949.                               if(┬º┬ºpop())
  950.                               {
  951.                                  set("\x01",eval("\x01") + 138);
  952.                               }
  953.                            }
  954.                            else
  955.                            {
  956.                               if(eval("\x01") == 890)
  957.                               {
  958.                                  set("\x01",eval("\x01") - 831);
  959.                                  nextFrame();
  960.                                  break loop0;
  961.                               }
  962.                               if(eval("\x01") == 561)
  963.                               {
  964.                                  set("\x01",eval("\x01") + 146);
  965.                                  if(┬º┬ºpop())
  966.                                  {
  967.                                     set("\x01",eval("\x01") - 331);
  968.                                  }
  969.                               }
  970.                               else if(eval("\x01") == 59)
  971.                               {
  972.                                  set("\x01",eval("\x01") + 902);
  973.                                  ┬º┬ºpush(true);
  974.                               }
  975.                               else if(eval("\x01") == 769)
  976.                               {
  977.                                  set("\x01",eval("\x01") - 404);
  978.                                  if(┬º┬ºpop())
  979.                                  {
  980.                                     set("\x01",eval("\x01") + 227);
  981.                                  }
  982.                               }
  983.                               else if(eval("\x01") == 923)
  984.                               {
  985.                                  set("\x01",eval("\x01") - 413);
  986.                                  if(┬º┬ºpop())
  987.                                  {
  988.                                     set("\x01",eval("\x01") - 426);
  989.                                  }
  990.                               }
  991.                               else if(eval("\x01") == 376)
  992.                               {
  993.                                  set("\x01",eval("\x01") + 547);
  994.                                  ┬º┬ºpush(true);
  995.                               }
  996.                               else
  997.                               {
  998.                                  if(eval("\x01") == 707)
  999.                                  {
  1000.                                     set("\x01",eval("\x01") - 331);
  1001.                                     break loop0;
  1002.                                  }
  1003.                                  if(eval("\x01") == 365)
  1004.                                  {
  1005.                                     set("\x01",eval("\x01") + 227);
  1006.                                     break loop0;
  1007.                                  }
  1008.                                  if(eval("\x01") == 505)
  1009.                                  {
  1010.                                     set("\x01",eval("\x01") + 23);
  1011.                                     break loop0;
  1012.                                  }
  1013.                                  if(eval("\x01") == 137)
  1014.                                  {
  1015.                                     set("\x01",eval("\x01") + 472);
  1016.                                     set(┬º┬ºpop(),eval(┬º┬ºpop()) + 132);
  1017.                                     pr._alpha = 0;
  1018.                                     step = 10;
  1019.                                     this.onEnterFrame = function()
  1020.                                     {
  1021.                                        pr.gotoAndStop(Math.round(100 * _root.getBytesLoaded() / _root.getBytesTotal()));
  1022.                                        pr._alpha += step;
  1023.                                        if(pr._alpha > 100)
  1024.                                        {
  1025.                                           pr._alpha = 100;
  1026.                                           step = 0;
  1027.                                        }
  1028.                                        if(step < 0)
  1029.                                        {
  1030.                                           this._alpha += step;
  1031.                                        }
  1032.                                        if(this._alpha <= 0)
  1033.                                        {
  1034.                                           this._parent.loaded();
  1035.                                        }
  1036.                                        if(_root.getBytesLoaded() == _root.getBytesTotal())
  1037.                                        {
  1038.                                           step = -10;
  1039.                                        }
  1040.                                     };
  1041.                                     stop();
  1042.                                     break loop0;
  1043.                                  }
  1044.                                  if(eval("\x01") == 510)
  1045.                                  {
  1046.                                     set("\x01",eval("\x01") - 426);
  1047.                                     var _loc7_ = new Vector.poly(N[┬º┬ºconstant(53)] * t * _loc6_,┬º┬ºpop()[┬º┬ºpop()] * t * _loc6_);
  1048.                                     engine.Screen = function()
  1049.                                     {
  1050.                                        super();
  1051.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1052.                                        this.gameArea = this.level4.level3.level2.level1;
  1053.                                        this.cameraSpeed = 100;
  1054.                                        this.poleRot = 0;
  1055.                                        this.scale = 400;
  1056.                                     }._rotation[┬º┬ºconstant(91)](_loc7_);
  1057.                                     _loc4_ = obj._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(53)] - engine.Screen = function()
  1058.                                     {
  1059.                                        super();
  1060.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1061.                                        this.gameArea = this.level4.level3.level2.level1;
  1062.                                        this.cameraSpeed = 100;
  1063.                                        this.poleRot = 0;
  1064.                                        this.scale = 400;
  1065.                                     }._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  1066.                                     var _loc3_ = obj._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(50)] - engine.Screen = function()
  1067.                                     {
  1068.                                        super();
  1069.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1070.                                        this.gameArea = this.level4.level3.level2.level1;
  1071.                                        this.cameraSpeed = 100;
  1072.                                        this.poleRot = 0;
  1073.                                        this.scale = 400;
  1074.                                     }._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  1075.                                     _loc9_ = eval(┬º┬ºconstant(58))[┬º┬ºconstant(74)](eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc4_),eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc3_));
  1076.                                     _loc4_ /= _loc9_;
  1077.                                     _loc3_ /= _loc9_;
  1078.                                     _loc10_ = new Vector.poly(_loc4_,_loc3_);
  1079.                                     var _loc5_ = engine.Screen = function()
  1080.                                     {
  1081.                                        super();
  1082.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1083.                                        this.gameArea = this.level4.level3.level2.level1;
  1084.                                        this.cameraSpeed = 100;
  1085.                                        this.poleRot = 0;
  1086.                                        this.scale = 400;
  1087.                                     }.getRotation[┬º┬ºconstant(77)]();
  1088.                                     _loc9_ = engine.Screen = function()
  1089.                                     {
  1090.                                        super();
  1091.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1092.                                        this.gameArea = this.level4.level3.level2.level1;
  1093.                                        this.cameraSpeed = 100;
  1094.                                        this.poleRot = 0;
  1095.                                        this.scale = 400;
  1096.                                     }.getX + obj.getX;
  1097.                                     _loc11_ = _loc10_[┬º┬ºconstant(75)](_loc5_ * (engine.Screen = function()
  1098.                                     {
  1099.                                        super();
  1100.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1101.                                        this.gameArea = this.level4.level3.level2.level1;
  1102.                                        this.cameraSpeed = 100;
  1103.                                        this.poleRot = 0;
  1104.                                        this.scale = 400;
  1105.                                     }.getX / _loc9_))[┬º┬ºconstant(107)](180);
  1106.                                     _root[┬º┬ºconstant(39)][┬º┬ºconstant(40)](┬º┬ºconstant(108),0,false,_loc5_ / 2 / engine.Screen = function()
  1107.                                     {
  1108.                                        super();
  1109.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1110.                                        this.gameArea = this.level4.level3.level2.level1;
  1111.                                        this.cameraSpeed = 100;
  1112.                                        this.poleRot = 0;
  1113.                                        this.scale = 400;
  1114.                                     }.gameEngine);
  1115.                                     (engine.Screen = function()
  1116.                                     {
  1117.                                        super();
  1118.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1119.                                        this.gameArea = this.level4.level3.level2.level1;
  1120.                                        this.cameraSpeed = 100;
  1121.                                        this.poleRot = 0;
  1122.                                        this.scale = 400;
  1123.                                     })[┬º┬ºconstant(109)](_loc11_);
  1124.                                     addr6160:
  1125.                                     ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1126.                                     _loc2_[┬º┬ºconstant(111)] = function()
  1127.                                     {
  1128.                                        return this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  1129.                                     };
  1130.                                     _loc2_[┬º┬ºconstant(112)] = function()
  1131.                                     {
  1132.                                        return this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  1133.                                     };
  1134.                                     _loc2_[┬º┬ºconstant(113)] = function()
  1135.                                     {
  1136.                                        return this.mass;
  1137.                                     };
  1138.                                     _loc2_[┬º┬ºconstant(109)] = function(V)
  1139.                                     {
  1140.                                        this.__get__y[┬º┬ºconstant(78)](V);
  1141.                                     };
  1142.                                     _loc2_[┬º┬ºconstant(114)] = function(g)
  1143.                                     {
  1144.                                        this.update[┬º┬ºconstant(115)](g);
  1145.                                     };
  1146.                                     _loc2_[┬º┬ºconstant(104)] = function()
  1147.                                     {
  1148.                                        this._rotation[┬º┬ºconstant(116)]();
  1149.                                        for(var _loc2_ in this.update)
  1150.                                        {
  1151.                                           this.update[_loc2_][┬º┬ºconstant(80)][┬º┬ºconstant(117)](this.update[_loc2_],this);
  1152.                                        }
  1153.                                     };
  1154.                                     _loc2_[┬º┬ºconstant(118)] = function(code1, code2, code3, code4)
  1155.                                     {
  1156.                                        this[┬º┬ºconstant(85)] = new _parent();
  1157.                                        var _loc3_ = 0;
  1158.                                        while(_loc3_ < arguments[┬º┬ºconstant(119)])
  1159.                                        {
  1160.                                           this[┬º┬ºconstant(85)][┬º┬ºconstant(115)](arguments[_loc3_]);
  1161.                                           _loc3_ = _loc3_ + 1;
  1162.                                        }
  1163.                                        this.updateObject = true;
  1164.                                     };
  1165.                                     _loc2_[┬º┬ºconstant(120)] = function(kof)
  1166.                                     {
  1167.                                        this.prototype = kof;
  1168.                                        this.updateObject = false;
  1169.                                     };
  1170.                                     _loc2_[┬º┬ºconstant(121)] = function(p1, p2)
  1171.                                     {
  1172.                                        this[┬º┬ºconstant(122)] = p1;
  1173.                                        this[┬º┬ºconstant(123)] = p2;
  1174.                                     };
  1175.                                     _loc2_[┬º┬ºconstant(124)] = function()
  1176.                                     {
  1177.                                        this[┬º┬ºconstant(69)] = this.getY;
  1178.                                        if(this.updateObject)
  1179.                                        {
  1180.                                           this.ASSetPropFlags = this[┬º┬ºconstant(84)];
  1181.                                        }
  1182.                                        else
  1183.                                        {
  1184.                                           this.ASSetPropFlags = this[┬º┬ºconstant(72)];
  1185.                                        }
  1186.                                     };
  1187.                                     ┬º┬ºconstant(125)(engine.Obj[┬º┬ºconstant(45)],null,1);
  1188.                                     break loop0;
  1189.                                  }
  1190.                                  if(eval("\x01") == 609)
  1191.                                  {
  1192.                                     set("\x01",eval("\x01") + 160);
  1193.                                     ┬º┬ºpush(true);
  1194.                                  }
  1195.                                  else
  1196.                                  {
  1197.                                     if(eval("\x01") != 241)
  1198.                                     {
  1199.                                        break;
  1200.                                     }
  1201.                                     set("\x01",eval("\x01") + 264);
  1202.                                     if(┬º┬ºpop())
  1203.                                     {
  1204.                                        set("\x01",eval("\x01") + 23);
  1205.                                     }
  1206.                                  }
  1207.                               }
  1208.                            }
  1209.                         }
  1210.                         continue;
  1211.                         addr2828:
  1212.                      }
  1213.                      else
  1214.                      {
  1215.                         ┬º┬ºpush(eval("\x01") != 454);
  1216.                         while(true)
  1217.                         {
  1218.                            if(!┬º┬ºpop())
  1219.                            {
  1220.                               set("\x01",eval("\x01") - 317);
  1221.                               if(┬º┬ºpop())
  1222.                               {
  1223.                                  set("\x01",eval("\x01") + 472);
  1224.                               }
  1225.                            }
  1226.                            else if(eval("\x01") == 975)
  1227.                            {
  1228.                               set("\x01",eval("\x01") - 734);
  1229.                               ┬º┬ºgoto(addr2828);
  1230.                               ┬º┬ºpush(true);
  1231.                            }
  1232.                            else
  1233.                            {
  1234.                               if(eval("\x01") == 377)
  1235.                               {
  1236.                                  set("\x01",eval("\x01") + 598);
  1237.                                  toggleHighQuality();
  1238.                                  stopAllSounds();
  1239.                                  _loc5_ = ┬º┬ºpop() - ┬º┬ºpop()[┬º┬ºpop()][┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  1240.                                  _loc4_ = auto._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(50)] - engine.Screen = function()
  1241.                                  {
  1242.                                     super();
  1243.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1244.                                     this.gameArea = this.level4.level3.level2.level1;
  1245.                                     this.cameraSpeed = 100;
  1246.                                     this.poleRot = 0;
  1247.                                     this.scale = 400;
  1248.                                  }._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  1249.                                  _loc7_ = eval(┬º┬ºconstant(58))[┬º┬ºconstant(74)](eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc5_),eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc4_));
  1250.                                  _loc5_ /= _loc7_;
  1251.                                  _loc4_ /= _loc7_;
  1252.                                  _loc9_ = new Vector.poly(_loc5_,_loc4_);
  1253.                                  var _loc6_ = engine.Screen = function()
  1254.                                  {
  1255.                                     super();
  1256.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1257.                                     this.gameArea = this.level4.level3.level2.level1;
  1258.                                     this.cameraSpeed = 100;
  1259.                                     this.poleRot = 0;
  1260.                                     this.scale = 400;
  1261.                                  }.getRotation[┬º┬ºconstant(77)]() + auto.getRotation[┬º┬ºconstant(77)]();
  1262.                                  _loc7_ = engine.Screen = function()
  1263.                                  {
  1264.                                     super();
  1265.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1266.                                     this.gameArea = this.level4.level3.level2.level1;
  1267.                                     this.cameraSpeed = 100;
  1268.                                     this.poleRot = 0;
  1269.                                     this.scale = 400;
  1270.                                  }.getX + auto.getX;
  1271.                                  var _loc12_ = _loc9_[┬º┬ºconstant(75)](_loc6_ * (engine.Screen = function()
  1272.                                  {
  1273.                                     super();
  1274.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1275.                                     this.gameArea = this.level4.level3.level2.level1;
  1276.                                     this.cameraSpeed = 100;
  1277.                                     this.poleRot = 0;
  1278.                                     this.scale = 400;
  1279.                                  }.getX / _loc7_) * 0.5)[┬º┬ºconstant(107)](180);
  1280.                                  _loc11_ = _loc9_[┬º┬ºconstant(75)](_loc6_ * (auto.getX / _loc7_) * 0.5);
  1281.                                  _root[┬º┬ºconstant(39)][┬º┬ºconstant(40)](┬º┬ºconstant(108),0,false,_loc6_ / 2 / engine.Screen = function()
  1282.                                  {
  1283.                                     super();
  1284.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1285.                                     this.gameArea = this.level4.level3.level2.level1;
  1286.                                     this.cameraSpeed = 100;
  1287.                                     this.poleRot = 0;
  1288.                                     this.scale = 400;
  1289.                                  }.gameEngine);
  1290.                                  (engine.Screen = function()
  1291.                                  {
  1292.                                     super();
  1293.                                     this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1294.                                     this.gameArea = this.level4.level3.level2.level1;
  1295.                                     this.cameraSpeed = 100;
  1296.                                     this.poleRot = 0;
  1297.                                     this.scale = 400;
  1298.                                  })[┬º┬ºconstant(109)](_loc12_);
  1299.                                  auto[┬º┬ºconstant(109)](_loc11_);
  1300.                                  addr6033:
  1301.                                  ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1302.                                  ┬º┬ºpush(_loc2_);
  1303.                                  ┬º┬ºpush(┬º┬ºconstant(110));
  1304.                               }
  1305.                               else
  1306.                               {
  1307.                                  if(eval("\x01") == 602)
  1308.                                  {
  1309.                                     set("\x01",eval("\x01") - 225);
  1310.                                     if(┬º┬ºpop())
  1311.                                     {
  1312.                                        set("\x01",eval("\x01") + 598);
  1313.                                     }
  1314.                                     ┬º┬ºgoto(addr2828);
  1315.                                  }
  1316.                                  else if(eval("\x01") == 105)
  1317.                                  {
  1318.                                     set("\x01",eval("\x01") + 138);
  1319.                                     toggleHighQuality();
  1320.                                     toggleHighQuality();
  1321.                                     ┬º┬ºpop()[┬º┬ºpop()].verifytext = engine.Screen = function()
  1322.                                     {
  1323.                                        super();
  1324.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1325.                                        this.gameArea = this.level4.level3.level2.level1;
  1326.                                        this.cameraSpeed = 100;
  1327.                                        this.poleRot = 0;
  1328.                                        this.scale = 400;
  1329.                                     }.prototype.verifytext - (engine.Screen = function()
  1330.                                     {
  1331.                                        super();
  1332.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1333.                                        this.gameArea = this.level4.level3.level2.level1;
  1334.                                        this.cameraSpeed = 100;
  1335.                                        this.poleRot = 0;
  1336.                                        this.scale = 400;
  1337.                                     }.prototype.verifytext - _loc2_) / 50;
  1338.                                     engine.Screen = function()
  1339.                                     {
  1340.                                        super();
  1341.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1342.                                        this.gameArea = this.level4.level3.level2.level1;
  1343.                                        this.cameraSpeed = 100;
  1344.                                        this.poleRot = 0;
  1345.                                        this.scale = 400;
  1346.                                     }.prototype.makeSig = engine.Screen = function()
  1347.                                     {
  1348.                                        super();
  1349.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1350.                                        this.gameArea = this.level4.level3.level2.level1;
  1351.                                        this.cameraSpeed = 100;
  1352.                                        this.poleRot = 0;
  1353.                                        this.scale = 400;
  1354.                                     }.prototype.makeSig - (engine.Screen = function()
  1355.                                     {
  1356.                                        super();
  1357.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1358.                                        this.gameArea = this.level4.level3.level2.level1;
  1359.                                        this.cameraSpeed = 100;
  1360.                                        this.poleRot = 0;
  1361.                                        this.scale = 400;
  1362.                                     }.prototype.makeSig - _loc2_) / 50;
  1363.                                     engine.Screen = function()
  1364.                                     {
  1365.                                        super();
  1366.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1367.                                        this.gameArea = this.level4.level3.level2.level1;
  1368.                                        this.cameraSpeed = 100;
  1369.                                        this.poleRot = 0;
  1370.                                        this.scale = 400;
  1371.                                     }[┬º┬ºconstant(64)] = engine.Screen = function()
  1372.                                     {
  1373.                                        super();
  1374.                                        this.arrowMc = this.createEmptyMovieClip("arrowMc",this.getNextHighestDepth());
  1375.                                        this.gameArea = this.level4.level3.level2.level1;
  1376.                                        this.cameraSpeed = 100;
  1377.                                        this.poleRot = 0;
  1378.                                        this.scale = 400;
  1379.                                     }.prototype.verifytext;
  1380.                                     ┬º┬ºgoto(addr2633);
  1381.                                  }
  1382.                                  else
  1383.                                  {
  1384.                                     if(eval("\x01") == 215)
  1385.                                     {
  1386.                                        set("\x01",eval("\x01") + 454);
  1387.                                        ┬º┬ºpop() extends ┬º┬ºpop() | (┬º┬ºpop() | ┬º┬ºpop() << ┬º┬ºpop() % (┬º┬ºpop() << (┬º┬ºpop() >>> (┬º┬ºpop() gt ┬º┬ºpop() >>> (┬º┬ºpop() | ┬º┬ºpop())))));
  1388.                                        trace(┬º┬ºpop() << (┬º┬ºpop() gt (┬º┬ºpop() > ┬º┬ºpop())()));
  1389.                                        trace(┬º┬ºpop() << (┬º┬ºpop() gt (┬º┬ºpop() >>> (┬º┬ºpop() << ┬º┬ºpop()))()));
  1390.                                        ┬º┬ºpop() extends ┬º┬ºpop() >> (┬º┬ºpop() >>> ┬º┬ºpop());
  1391.                                        ┬º┬ºpush(┬º┬ºpop() >>> (┬º┬ºpop() >> (┬º┬ºpop() | ┬º┬ºpop() >>> ┬º┬ºpop()())));
  1392.                                        break loop0;
  1393.                                     }
  1394.                                     if(eval("\x01") != 669)
  1395.                                     {
  1396.                                        break loop0;
  1397.                                     }
  1398.                                     set("\x01",eval("\x01") - 215);
  1399.                                     ┬º┬ºgoto(addr2828);
  1400.                                     ┬º┬ºpush(true);
  1401.                                  }
  1402.                                  ┬º┬ºgoto(addr2828);
  1403.                               }
  1404.                               ┬º┬ºgoto(addr6160);
  1405.                            }
  1406.                            ┬º┬ºgoto(addr2828);
  1407.                         }
  1408.                         addr3173:
  1409.                      }
  1410.                      ┬º┬ºgoto(addr2828);
  1411.                      ┬º┬ºgoto(addr2633);
  1412.                   }
  1413.                   ┬º┬ºgoto(addr2828);
  1414.                }
  1415.             }
  1416.          }
  1417.          else
  1418.          {
  1419.             if(eval("\x01") == 544)
  1420.             {
  1421.                set("\x01",eval("\x01") - 453);
  1422.                ┬º┬ºpush(true);
  1423.                continue;
  1424.             }
  1425.             if(eval("\x01") == 779)
  1426.             {
  1427.                set("\x01",eval("\x01") - 363);
  1428.                ┬º┬ºpush(true);
  1429.                continue;
  1430.             }
  1431.             if(eval("\x01") == 516)
  1432.             {
  1433.                set("\x01",eval("\x01") - 413);
  1434.                ┬º┬ºpush(true);
  1435.                continue;
  1436.             }
  1437.             if(eval("\x01") == 667)
  1438.             {
  1439.                set("\x01",eval("\x01") + 214);
  1440.                ┬º┬ºpush(true);
  1441.                continue;
  1442.             }
  1443.             if(eval("\x01") == 9)
  1444.             {
  1445.                set("\x01",eval("\x01") + 210);
  1446.                ┬º┬ºpush(true);
  1447.                continue;
  1448.             }
  1449.             if(eval("\x01") != 661)
  1450.             {
  1451.                if(eval("\x01") == 528)
  1452.                {
  1453.                   set("\x01",eval("\x01") + 133);
  1454.                   if(┬º┬ºpop())
  1455.                   {
  1456.                      set("\x01",eval("\x01") - 652);
  1457.                   }
  1458.                }
  1459.                else
  1460.                {
  1461.                   if(eval("\x01") == 199)
  1462.                   {
  1463.                      break loop1;
  1464.                   }
  1465.                   if(eval("\x01") == 520)
  1466.                   {
  1467.                      set("\x01",eval("\x01") + 147);
  1468.                      break loop0;
  1469.                   }
  1470.                   if(eval("\x01") == 939)
  1471.                   {
  1472.                      set("\x01",eval("\x01") - 160);
  1473.                      break loop0;
  1474.                   }
  1475.                   if(eval("\x01") == 247)
  1476.                   {
  1477.                      set("\x01",eval("\x01") - 188);
  1478.                      ┬º┬ºpush(true);
  1479.                   }
  1480.                   else if(eval("\x01") == 938)
  1481.                   {
  1482.                      set("\x01",eval("\x01") - 410);
  1483.                      ┬º┬ºpush(true);
  1484.                   }
  1485.                   else
  1486.                   {
  1487.                      if(eval("\x01") == 622)
  1488.                      {
  1489.                         set("\x01",eval("\x01") - 45);
  1490.                         if(!_global.engine)
  1491.                         {
  1492.                            _global.engine = new Object();
  1493.                         }
  1494.                         ┬º┬ºpop();
  1495.                         if(!_global.engine.Obj)
  1496.                         {
  1497.                            engine.Obj = _loc1_ = function(goal, nname, objIni, vert)
  1498.                            {
  1499.                               var _loc3_ = new math.Vector(objIni._x,objIni._y);
  1500.                               this.poly = new math.Polygon(goal,nname,_loc3_,vert,objIni._rotation);
  1501.                               this.objRotation = objIni._rotation;
  1502.                               this.poly.drawPoly();
  1503.                               this.mass = 500;
  1504.                               this.objName = nname;
  1505.                               this.gameEngine = goal;
  1506.                               this.skins = new Array();
  1507.                            };
  1508.                            _loc2_ = _loc1_.prototype;
  1509.                            _loc2_.destroy = function()
  1510.                            {
  1511.                               for(var _loc2_ in this)
  1512.                               {
  1513.                                  this[_loc2_].removeMovieClip();
  1514.                                  delete this[_loc2_];
  1515.                               }
  1516.                            };
  1517.                            _loc2_.iteration = function()
  1518.                            {
  1519.                               this.renderObj();
  1520.                            };
  1521.                            _loc2_.getX = function()
  1522.                            {
  1523.                               return this.poly.pos.__get__x();
  1524.                            };
  1525.                            _loc2_.getY = function()
  1526.                            {
  1527.                               return this.poly.pos.__get__y();
  1528.                            };
  1529.                            _loc2_.getRotation = function()
  1530.                            {
  1531.                               return this.objRotation;
  1532.                            };
  1533.                            _loc2_.addSkin = function(g)
  1534.                            {
  1535.                               this.skins.push(g);
  1536.                            };
  1537.                            _loc2_.update = function()
  1538.                            {
  1539.                               this.renderObj();
  1540.                            };
  1541.                            _loc2_.renderObj = function()
  1542.                            {
  1543.                               this.poly.drawPoly();
  1544.                               for(var _loc2_ in this.skins)
  1545.                               {
  1546.                                  this.skins[_loc2_]._parent.updateObject(this.skins[_loc2_],this);
  1547.                               }
  1548.                            };
  1549.                            ┬º┬ºpush(ASSetPropFlags(engine.Obj.prototype,null,1));
  1550.                         }
  1551.                         ┬º┬ºpop();
  1552.                         break loop0;
  1553.                      }
  1554.                      if(eval("\x01") == 59)
  1555.                      {
  1556.                         set("\x01",eval("\x01") - 20);
  1557.                         if(┬º┬ºpop())
  1558.                         {
  1559.                            set("\x01",eval("\x01") + 918);
  1560.                         }
  1561.                      }
  1562.                      else if(eval("\x01") == 881)
  1563.                      {
  1564.                         set("\x01",eval("\x01") - 513);
  1565.                         if(┬º┬ºpop())
  1566.                         {
  1567.                            set("\x01",eval("\x01") - 139);
  1568.                         }
  1569.                      }
  1570.                      else if(eval("\x01") == 416)
  1571.                      {
  1572.                         set("\x01",eval("\x01") + 104);
  1573.                         if(┬º┬ºpop())
  1574.                         {
  1575.                            set("\x01",eval("\x01") + 147);
  1576.                         }
  1577.                      }
  1578.                      else
  1579.                      {
  1580.                         if(eval("\x01") == 368)
  1581.                         {
  1582.                            set("\x01",eval("\x01") - 139);
  1583.                            break loop0;
  1584.                         }
  1585.                         if(eval("\x01") == 308)
  1586.                         {
  1587.                            set("\x01",eval("\x01") - 109);
  1588.                            if(┬º┬ºpop())
  1589.                            {
  1590.                               set("\x01",eval("\x01") + 739);
  1591.                            }
  1592.                         }
  1593.                         else if(eval("\x01") == 229)
  1594.                         {
  1595.                            set("\x01",eval("\x01") + 406);
  1596.                            ┬º┬ºpush(true);
  1597.                         }
  1598.                         else
  1599.                         {
  1600.                            if(eval("\x01") != 635)
  1601.                            {
  1602.                               if(eval("\x01") == 272)
  1603.                               {
  1604.                                  set("\x01",eval("\x01") - 25);
  1605.                                  ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  1606.                                  break loop0;
  1607.                               }
  1608.                               break loop0;
  1609.                            }
  1610.                            set("\x01",eval("\x01") - 363);
  1611.                            if(┬º┬ºpop())
  1612.                            {
  1613.                               set("\x01",eval("\x01") - 25);
  1614.                            }
  1615.                         }
  1616.                      }
  1617.                   }
  1618.                }
  1619.                continue;
  1620.             }
  1621.             set("\x01",eval("\x01") - 652);
  1622.             loop7:
  1623.             while(true)
  1624.             {
  1625.                if(┬º┬ºpop() == 483)
  1626.                {
  1627.                   set("\x01",eval("\x01") - 205);
  1628.                   break loop0;
  1629.                }
  1630.                if(eval("\x01") == 278)
  1631.                {
  1632.                   set("\x01",eval("\x01") + 406);
  1633.                   ┬º┬ºpush(true);
  1634.                }
  1635.                else if(eval("\x01") == 701)
  1636.                {
  1637.                   set("\x01",eval("\x01") - 151);
  1638.                   if(┬º┬ºpop())
  1639.                   {
  1640.                      set("\x01",eval("\x01") - 186);
  1641.                   }
  1642.                }
  1643.                else if(eval("\x01") == 684)
  1644.                {
  1645.                   set("\x01",eval("\x01") - 202);
  1646.                   if(┬º┬ºpop())
  1647.                   {
  1648.                      set("\x01",eval("\x01") + 125);
  1649.                   }
  1650.                }
  1651.                else if(eval("\x01") == 364)
  1652.                {
  1653.                   set("\x01",eval("\x01") + 244);
  1654.                   ┬º┬ºpush(true);
  1655.                }
  1656.                else if(eval("\x01") == 607)
  1657.                {
  1658.                   set("\x01",eval("\x01") + 94);
  1659.                   ┬º┬ºpush(true);
  1660.                }
  1661.                else if(eval("\x01") == 608)
  1662.                {
  1663.                   set("\x01",eval("\x01") + 138);
  1664.                   if(┬º┬ºpop())
  1665.                   {
  1666.                      set("\x01",eval("\x01") - 135);
  1667.                   }
  1668.                }
  1669.                else
  1670.                {
  1671.                   if(eval("\x01") == 746)
  1672.                   {
  1673.                      set("\x01",eval("\x01") - 135);
  1674.                      nextFrame();
  1675.                      toggleHighQuality();
  1676.                      ┬º┬ºpop() implements ;
  1677.                      var _loc1_ = ┬º┬ºpop()[┬º┬ºpop()];
  1678.                      _loc1_._y[_loc1_.Vector][┬º┬ºconstant(43)]();
  1679.                      set(┬º┬ºconstant(40),_loc1_.poly);
  1680.                      _loc1_[┬º┬ºconstant(41)] = function()
  1681.                      {
  1682.                         set(┬º┬ºconstant(40),eval(┬º┬ºconstant(40)) - 1);
  1683.                         this._y[this.Vector]._parent(eval(┬º┬ºconstant(40)));
  1684.                         if(eval(┬º┬ºconstant(40)) <= 0)
  1685.                         {
  1686.                            this._y[this.Vector][┬º┬ºconstant(42)]();
  1687.                            this[┬º┬ºconstant(41)] = null;
  1688.                            this[┬º┬ºconstant(36)](this.Vector + 1);
  1689.                         }
  1690.                      };
  1691.                      _loc1_._y[_loc1_.Vector][┬º┬ºconstant(45)] = null;
  1692.                      ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1693.                      ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  1694.                      _loc2_[┬º┬ºconstant(46)] = function()
  1695.                      {
  1696.                         this[┬º┬ºconstant(40)] = this.poly;
  1697.                         this[┬º┬ºconstant(41)] = function()
  1698.                         {
  1699.                            this[┬º┬ºconstant(40)] -= 5;
  1700.                            this._y[this.Vector]._parent(this[┬º┬ºconstant(40)]);
  1701.                            if(this[┬º┬ºconstant(40)] <= 0)
  1702.                            {
  1703.                               this._y[this.Vector][┬º┬ºconstant(42)]();
  1704.                               this.Vector = null;
  1705.                               this[┬º┬ºconstant(41)] = null;
  1706.                            }
  1707.                         };
  1708.                      };
  1709.                      _loc2_[┬º┬ºconstant(47)] = function(how)
  1710.                      {
  1711.                         if(how)
  1712.                         {
  1713.                            this[┬º┬ºconstant(40)] = this.poly;
  1714.                            this[┬º┬ºconstant(41)] = function()
  1715.                            {
  1716.                               this[┬º┬ºconstant(40)] -= 5;
  1717.                               this._y[this.Vector]._parent(this[┬º┬ºconstant(40)]);
  1718.                               if(this[┬º┬ºconstant(40)] <= 0)
  1719.                               {
  1720.                                  this._y[this.Vector][┬º┬ºconstant(42)]();
  1721.                                  this[┬º┬ºconstant(41)] = null;
  1722.                               }
  1723.                            };
  1724.                         }
  1725.                         else
  1726.                         {
  1727.                            this[┬º┬ºconstant(36)](this.Vector);
  1728.                         }
  1729.                      };
  1730.                      ┬º┬ºconstant(48)(engine.Obj.drawPoly,null,1);
  1731.                      break loop0;
  1732.                   }
  1733.                   if(eval("\x01") == 611)
  1734.                   {
  1735.                      set("\x01",eval("\x01") + 125);
  1736.                      ┬º┬ºpush(true);
  1737.                   }
  1738.                   else
  1739.                   {
  1740.                      if(eval("\x01") != 736)
  1741.                      {
  1742.                         if(eval("\x01") == 331)
  1743.                         {
  1744.                            set("\x01",eval("\x01") - 9);
  1745.                            stop();
  1746.                            break loop0;
  1747.                         }
  1748.                         if(eval("\x01") == 322)
  1749.                         {
  1750.                            set("\x01",eval("\x01") + 95);
  1751.                            addr3283:
  1752.                            if(!_global.engine)
  1753.                            {
  1754.                               count0.count1 = new state();
  1755.                            }
  1756.                            ┬º┬ºpop();
  1757.                            if(!count0.count1.Array)
  1758.                            {
  1759.                               count1.Array = _loc1_ = function()
  1760.                               {
  1761.                                  super();
  1762.                                  this.buffer = 0;
  1763.                                  this.transformBuffer = 0;
  1764.                               };
  1765.                               count1.Array extends digestBits;
  1766.                               _loc2_ = _loc1_.Fmd5Class;
  1767.                               _loc2_.prototype = function(currentLevel)
  1768.                               {
  1769.                                  this.MovieClip.rol();
  1770.                                  this.GG("MovieClip" + currentLevel,"MovieClip",this.FF());
  1771.                                  var _loc2_ = 0;
  1772.                                  var _loc3_ = this.MovieClip["HH" + _loc2_];
  1773.                                  while(_loc3_ != undefined)
  1774.                                  {
  1775.                                     _loc2_ = _loc2_ + 1;
  1776.                                     _loc3_ = this.MovieClip["HH" + _loc2_];
  1777.                                  }
  1778.                                  this.II = _loc2_;
  1779.                               };
  1780.                               _loc2_.II = 0;
  1781.                               ┬º┬ºpush(transformMD5(count1.Array.Fmd5Class,null,1));
  1782.                            }
  1783.                            ┬º┬ºpop();
  1784.                            break loop0;
  1785.                         }
  1786.                         break loop0;
  1787.                      }
  1788.                      set("\x01",eval("\x01") - 405);
  1789.                      if(┬º┬ºpop())
  1790.                      {
  1791.                         set("\x01",eval("\x01") - 9);
  1792.                      }
  1793.                   }
  1794.                }
  1795.                while(true)
  1796.                {
  1797.                   if(eval("\x01") == 989)
  1798.                   {
  1799.                      set("\x01",eval("\x01") - 801);
  1800.                      ┬º┬ºpush(true);
  1801.                      continue;
  1802.                   }
  1803.                   if(eval("\x01") == 627)
  1804.                   {
  1805.                      set("\x01",eval("\x01") - 211);
  1806.                      ┬º┬ºpop();
  1807.                      this.Fmd5Class[┬º┬ºconstant(39)] -= (_loc2_[┬º┬ºconstant(51)] + this.Fmd5Class[┬º┬ºconstant(39)]) / 5;
  1808.                      this.Fmd5Class[┬º┬ºconstant(40)] -= (_loc2_[┬º┬ºconstant(53)] + this.Fmd5Class[┬º┬ºconstant(40)]) / 5;
  1809.                   }
  1810.                   else
  1811.                   {
  1812.                      if(eval("\x01") == 660)
  1813.                      {
  1814.                         set("\x01",eval("\x01") + 135);
  1815.                         ┬º┬ºpush(true);
  1816.                         continue;
  1817.                      }
  1818.                      if(eval("\x01") == 973)
  1819.                      {
  1820.                         set("\x01",eval("\x01") - 917);
  1821.                         break loop0;
  1822.                      }
  1823.                      if(eval("\x01") == 550)
  1824.                      {
  1825.                         set("\x01",eval("\x01") - 186);
  1826.                         break loop0;
  1827.                      }
  1828.                      if(eval("\x01") == 681)
  1829.                      {
  1830.                         set("\x01",eval("\x01") - 21);
  1831.                         ┬º┬ºgoto(addr3173);
  1832.                      }
  1833.                      else
  1834.                      {
  1835.                         if(eval("\x01") == 148)
  1836.                         {
  1837.                            set("\x01",eval("\x01") - 104);
  1838.                            if(┬º┬ºpop())
  1839.                            {
  1840.                               set("\x01",eval("\x01") + 183);
  1841.                            }
  1842.                            continue;
  1843.                         }
  1844.                         if(eval("\x01") == 227)
  1845.                         {
  1846.                            set("\x01",eval("\x01") + 311);
  1847.                            ┬º┬ºpush(true);
  1848.                            continue;
  1849.                         }
  1850.                         if(eval("\x01") == 188)
  1851.                         {
  1852.                            set("\x01",eval("\x01") + 528);
  1853.                            if(┬º┬ºpop())
  1854.                            {
  1855.                               set("\x01",eval("\x01") - 16);
  1856.                            }
  1857.                            continue;
  1858.                         }
  1859.                         if(eval("\x01") == 700)
  1860.                         {
  1861.                            set("\x01",eval("\x01") - 652);
  1862.                            ┬º┬ºpush(true);
  1863.                            continue;
  1864.                         }
  1865.                         if(eval("\x01") == 538)
  1866.                         {
  1867.                            set("\x01",eval("\x01") + 143);
  1868.                            if(┬º┬ºpop())
  1869.                            {
  1870.                               set("\x01",eval("\x01") - 21);
  1871.                            }
  1872.                            continue;
  1873.                         }
  1874.                         if(eval("\x01") == 482)
  1875.                         {
  1876.                            set("\x01",eval("\x01") + 125);
  1877.                            loop19:
  1878.                            while(true)
  1879.                            {
  1880.                               if(!┬º┬ºpop())
  1881.                               {
  1882.                                  set("\x01",eval("\x01") + 390);
  1883.                                  if(┬º┬ºpop())
  1884.                                  {
  1885.                                     set("\x01",eval("\x01") - 313);
  1886.                                  }
  1887.                                  while(true)
  1888.                                  {
  1889.                                     if(eval("\x01") == 255)
  1890.                                     {
  1891.                                        set("\x01",eval("\x01") + 175);
  1892.                                        ┬º┬ºpush(true);
  1893.                                        continue;
  1894.                                     }
  1895.                                     if(eval("\x01") == 430)
  1896.                                     {
  1897.                                        set("\x01",eval("\x01") - 96);
  1898.                                        if(┬º┬ºpop())
  1899.                                        {
  1900.                                           set("\x01",eval("\x01") - 260);
  1901.                                        }
  1902.                                        continue;
  1903.                                     }
  1904.                                     if(eval("\x01") == 334)
  1905.                                     {
  1906.                                        break;
  1907.                                     }
  1908.                                     if(eval("\x01") == 74)
  1909.                                     {
  1910.                                        set("\x01",eval("\x01") + 375);
  1911.                                        ┬º┬ºpush(true);
  1912.                                        continue;
  1913.                                     }
  1914.                                     if(eval("\x01") == 862)
  1915.                                     {
  1916.                                        set("\x01",eval("\x01") - 152);
  1917.                                        eval(┬º┬ºpop() or ┬º┬ºpop()).sn.start();
  1918.                                        if(this["mc" + (this.indexSound - 100)].loop != true)
  1919.                                        {
  1920.                                           delete this["mc" + (this.indexSound - 100)].sn;
  1921.                                           this["mc" + (this.indexSound - 100)].removeMovieClip();
  1922.                                        }
  1923.                                        return mc.sn;
  1924.                                     }
  1925.                                     if(eval("\x01") == 449)
  1926.                                     {
  1927.                                        set("\x01",eval("\x01") + 413);
  1928.                                        if(┬º┬ºpop())
  1929.                                        {
  1930.                                           set("\x01",eval("\x01") - 152);
  1931.                                        }
  1932.                                        continue;
  1933.                                     }
  1934.                                     if(eval("\x01") == 710)
  1935.                                     {
  1936.                                        set("\x01",eval("\x01") - 196);
  1937.                                        ┬º┬ºpush(true);
  1938.                                        continue;
  1939.                                     }
  1940.                                     continue loop19;
  1941.                                  }
  1942.                                  set("\x01",eval("\x01") - 260);
  1943.                                  ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop() + 1);
  1944.                                  break loop0;
  1945.                               }
  1946.                               if(eval("\x01") == 904)
  1947.                               {
  1948.                                  set("\x01",eval("\x01") - 313);
  1949.                                  setProperty(┬º┬ºpop(), _X, ┬º┬ºpop());
  1950.                                  ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1951.                                  break loop0;
  1952.                               }
  1953.                               if(eval("\x01") == 591)
  1954.                               {
  1955.                                  set("\x01",eval("\x01") - 66);
  1956.                                  this._parent.stop();
  1957.                                  bg._x = 0;
  1958.                                  bg._y = 0;
  1959.                                  this._x = 0;
  1960.                                  this._y = 0;
  1961.                                  bg._width = Stage.width;
  1962.                                  bg._height = Stage.height;
  1963.                                  bg.swapDepths(10);
  1964.                                  _quality = "BEST";
  1965.                                  intro._xscale = 100;
  1966.                                  intro._yscale = 100;
  1967.                                  intro.swapDepths(11);
  1968.                                  intro._x = Math.round((Stage.width - intro._width) / 2);
  1969.                                  intro._y = Math.round((Stage.height - intro._height) / 2);
  1970.                                  loaded = function()
  1971.                                  {
  1972.                                     this._parent.gotoAndStop(2);
  1973.                                  };
  1974.                                  gotoGamezhero = function()
  1975.                                  {
  1976.                                     getUrl("http://www.gamezhero.com/?utm_campaign=hrc&utm_source=hrc&utm_medium=context_menu", "_blank");
  1977.                                  };
  1978.                                  gamezheroMenu = new ContextMenu();
  1979.                                  gamezheroMenu.builtInItems.forward_back = false;
  1980.                                  gamezheroMenu.builtInItems.loop = false;
  1981.                                  gamezheroMenu.builtInItems.play = false;
  1982.                                  gamezheroMenu.builtInItems.print = false;
  1983.                                  gamezheroMenu.builtInItems.rewind = false;
  1984.                                  gamezheroMenu.builtInItems.zoom = false;
  1985.                                  gamezheroMenu.builtInItems.save = false;
  1986.                                  gamezheroMenu.customItems.push(new ContextMenuItem("More Free Games - gamezhero.com",gotoGamezhero));
  1987.                                  _root.menu = gamezheroMenu;
  1988.                                  break loop0;
  1989.                               }
  1990.                               break loop0;
  1991.                            }
  1992.                         }
  1993.                         else
  1994.                         {
  1995.                            if(eval("\x01") == 56)
  1996.                            {
  1997.                               set("\x01",eval("\x01") + 92);
  1998.                               ┬º┬ºpush(true);
  1999.                               continue;
  2000.                            }
  2001.                            if(eval("\x01") == 48)
  2002.                            {
  2003.                               set("\x01",eval("\x01") + 579);
  2004.                               if(┬º┬ºpop())
  2005.                               {
  2006.                                  set("\x01",eval("\x01") - 211);
  2007.                               }
  2008.                               continue;
  2009.                            }
  2010.                            if(eval("\x01") != 716)
  2011.                            {
  2012.                               if(eval("\x01") == 416)
  2013.                               {
  2014.                                  set("\x01",eval("\x01") + 257);
  2015.                                  ┬º┬ºpush(true);
  2016.                                  continue;
  2017.                               }
  2018.                               if(eval("\x01") == 44)
  2019.                               {
  2020.                                  set("\x01",eval("\x01") + 183);
  2021.                                  toggleHighQuality();
  2022.                                  _loc4_ = ┬º┬ºpop()[┬º┬ºpop()].MovieClip.rol[┬º┬ºconstant(49)];
  2023.                                  _loc3_ = this.MD5Init[┬º┬ºconstant(58)]();
  2024.                                  _loc6_ = _loc3_ - _loc4_;
  2025.                                  _loc5_ = _loc4_ - _loc3_;
  2026.                                  this.HH += this[┬º┬ºconstant(48)](- _loc3_ - this.HH) / _root[┬º┬ºconstant(59)][┬º┬ºconstant(60)].GG;
  2027.                                  this.prototype.MovieClip.rol[┬º┬ºconstant(49)] = this.HH - 90;
  2028.                                  this.length.length[┬º┬ºconstant(49)] = _loc4_;
  2029.                                  break;
  2030.                               }
  2031.                               if(eval("\x01") == 795)
  2032.                               {
  2033.                                  set("\x01",eval("\x01") - 312);
  2034.                                  if(┬º┬ºpop())
  2035.                                  {
  2036.                                     set("\x01",eval("\x01") - 205);
  2037.                                  }
  2038.                                  continue;
  2039.                               }
  2040.                               if(eval("\x01") == 673)
  2041.                               {
  2042.                                  set("\x01",eval("\x01") + 300);
  2043.                                  if(┬º┬ºpop())
  2044.                                  {
  2045.                                     set("\x01",eval("\x01") - 917);
  2046.                                  }
  2047.                                  continue;
  2048.                               }
  2049.                               continue loop7;
  2050.                            }
  2051.                            set("\x01",eval("\x01") - 16);
  2052.                            while(true)
  2053.                            {
  2054.                               if(eval("\x01") == 827)
  2055.                               {
  2056.                                  set("\x01",eval("\x01") - 659);
  2057.                                  break loop0;
  2058.                               }
  2059.                               if(eval("\x01") != 34)
  2060.                               {
  2061.                                  if(eval("\x01") == 168)
  2062.                                  {
  2063.                                     set("\x01",eval("\x01") + 740);
  2064.                                     if(_root.getBytesLoaded() == _root.getBytesTotal())
  2065.                                     {
  2066.                                        stop();
  2067.                                        step = -10;
  2068.                                        this.onEnterFrame = function()
  2069.                                        {
  2070.                                           this._alpha += step;
  2071.                                           if(this._alpha <= 0)
  2072.                                           {
  2073.                                              this._parent.loaded();
  2074.                                           }
  2075.                                        };
  2076.                                     }
  2077.                                     gotoBtn.onRelease = function()
  2078.                                     {
  2079.                                        getUrl("http://www.gamezhero.com/?utm_campaign=hrc&utm_source=hrc&utm_medium=preloader", "zorroTeam");
  2080.                                     };
  2081.                                     break loop0;
  2082.                                  }
  2083.                                  break loop0;
  2084.                               }
  2085.                               set("\x01",eval("\x01") + 600);
  2086.                               if(┬º┬ºpop())
  2087.                               {
  2088.                                  set("\x01",eval("\x01") + 326);
  2089.                               }
  2090.                               while(true)
  2091.                               {
  2092.                                  if(eval("\x01") == 82)
  2093.                                  {
  2094.                                     set("\x01",eval("\x01") + 830);
  2095.                                     ┬º┬ºpush(true);
  2096.                                     continue;
  2097.                                  }
  2098.                                  if(eval("\x01") == 634)
  2099.                                  {
  2100.                                     set("\x01",eval("\x01") + 326);
  2101.                                     break loop0;
  2102.                                  }
  2103.                                  if(eval("\x01") == 217)
  2104.                                  {
  2105.                                     set("\x01",eval("\x01") + 79);
  2106.                                     break loop0;
  2107.                                  }
  2108.                                  if(eval("\x01") == 817)
  2109.                                  {
  2110.                                     set("\x01",eval("\x01") - 261);
  2111.                                     ┬º┬ºpush(true);
  2112.                                     continue;
  2113.                                  }
  2114.                                  if(eval("\x01") == 862)
  2115.                                  {
  2116.                                     set("\x01",eval("\x01") - 45);
  2117.                                     loop16:
  2118.                                     while(true)
  2119.                                     {
  2120.                                        set(┬º┬ºpop(),eval(┬º┬ºpop()) - 170);
  2121.                                        loop17:
  2122.                                        while(true)
  2123.                                        {
  2124.                                           while(true)
  2125.                                           {
  2126.                                              if(eval("\x01") == 498)
  2127.                                              {
  2128.                                                 set("\x01",eval("\x01") - 496);
  2129.                                                 ┬º┬ºpush(true);
  2130.                                              }
  2131.                                              else
  2132.                                              {
  2133.                                                 if(eval("\x01") == 311)
  2134.                                                 {
  2135.                                                    break loop17;
  2136.                                                 }
  2137.                                                 if(eval("\x01") == 521)
  2138.                                                 {
  2139.                                                    set("\x01",eval("\x01") - 412);
  2140.                                                    break loop0;
  2141.                                                 }
  2142.                                                 if(eval("\x01") == 753)
  2143.                                                 {
  2144.                                                    set("\x01",eval("\x01") - 232);
  2145.                                                    if(┬º┬ºpop())
  2146.                                                    {
  2147.                                                       set("\x01",eval("\x01") - 412);
  2148.                                                    }
  2149.                                                 }
  2150.                                                 else
  2151.                                                 {
  2152.                                                    if(eval("\x01") == 2)
  2153.                                                    {
  2154.                                                       break;
  2155.                                                    }
  2156.                                                    if(eval("\x01") != 141)
  2157.                                                    {
  2158.                                                       if(eval("\x01") == 109)
  2159.                                                       {
  2160.                                                          set("\x01",eval("\x01") + 9);
  2161.                                                          stop();
  2162.                                                          b.onPress = function()
  2163.                                                          {
  2164.                                                             getUrl("http://www.macromedia.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash?Lang=English&P5_Language=English", "_blank");
  2165.                                                             gotoAndStop(2);
  2166.                                                          };
  2167.                                                          break loop0;
  2168.                                                       }
  2169.                                                       break loop0;
  2170.                                                    }
  2171.                                                    set("\x01",eval("\x01") + 612);
  2172.                                                    ┬º┬ºpush(true);
  2173.                                                 }
  2174.                                              }
  2175.                                           }
  2176.                                           set("\x01",eval("\x01") + 309);
  2177.                                           if(!┬º┬ºpop())
  2178.                                           {
  2179.                                              continue;
  2180.                                           }
  2181.                                           continue loop16;
  2182.                                        }
  2183.                                        set("\x01",eval("\x01") - 170);
  2184.                                        break loop0;
  2185.                                     }
  2186.                                  }
  2187.                                  else
  2188.                                  {
  2189.                                     if(eval("\x01") == 912)
  2190.                                     {
  2191.                                        set("\x01",eval("\x01") - 559);
  2192.                                        if(┬º┬ºpop())
  2193.                                        {
  2194.                                           set("\x01",eval("\x01") + 166);
  2195.                                        }
  2196.                                        continue;
  2197.                                     }
  2198.                                     if(eval("\x01") == 582)
  2199.                                     {
  2200.                                        set("\x01",eval("\x01") + 245);
  2201.                                        if(┬º┬ºpop())
  2202.                                        {
  2203.                                           set("\x01",eval("\x01") - 659);
  2204.                                        }
  2205.                                        continue;
  2206.                                     }
  2207.                                     if(eval("\x01") != 353)
  2208.                                     {
  2209.                                        if(eval("\x01") == 519)
  2210.                                        {
  2211.                                           set("\x01",eval("\x01") - 485);
  2212.                                           ┬º┬ºpush(true);
  2213.                                        }
  2214.                                        else if(eval("\x01") == 534)
  2215.                                        {
  2216.                                           set("\x01",eval("\x01") + 328);
  2217.                                           if(┬º┬ºpop())
  2218.                                           {
  2219.                                              set("\x01",eval("\x01") - 45);
  2220.                                           }
  2221.                                        }
  2222.                                        else if(eval("\x01") == 960)
  2223.                                        {
  2224.                                           set("\x01",eval("\x01") - 426);
  2225.                                           ┬º┬ºpush(true);
  2226.                                        }
  2227.                                        else if(eval("\x01") == 296)
  2228.                                        {
  2229.                                           set("\x01",eval("\x01") + 286);
  2230.                                           ┬º┬ºpush(true);
  2231.                                        }
  2232.                                        else
  2233.                                        {
  2234.                                           if(eval("\x01") != 556)
  2235.                                           {
  2236.                                              break;
  2237.                                           }
  2238.                                           set("\x01",eval("\x01") - 339);
  2239.                                           if(┬º┬ºpop())
  2240.                                           {
  2241.                                              set("\x01",eval("\x01") + 79);
  2242.                                           }
  2243.                                        }
  2244.                                        continue;
  2245.                                     }
  2246.                                     set("\x01",eval("\x01") + 166);
  2247.                                     while(true)
  2248.                                     {
  2249.                                        if(┬º┬ºpop())
  2250.                                        {
  2251.                                           set("\x01",eval("\x01") - 50);
  2252.                                           nextFrame();
  2253.                                           break loop0;
  2254.                                        }
  2255.                                        if(eval("\x01") == 849)
  2256.                                        {
  2257.                                           set("\x01",eval("\x01") - 477);
  2258.                                           if(┬º┬ºpop())
  2259.                                           {
  2260.                                              set("\x01",eval("\x01") + 51);
  2261.                                           }
  2262.                                           continue;
  2263.                                        }
  2264.                                        if(eval("\x01") == 450)
  2265.                                        {
  2266.                                           set("\x01",eval("\x01") + 482);
  2267.                                           if(┬º┬ºpop())
  2268.                                           {
  2269.                                              set("\x01",eval("\x01") - 860);
  2270.                                           }
  2271.                                           continue;
  2272.                                        }
  2273.                                        if(eval("\x01") == 372)
  2274.                                        {
  2275.                                           set("\x01",eval("\x01") + 51);
  2276.                                           ┬º┬ºpop() extends ┬º┬ºpop()(┬º┬ºpop());
  2277.                                           break loop0;
  2278.                                        }
  2279.                                        if(eval("\x01") == 214)
  2280.                                        {
  2281.                                           set("\x01",eval("\x01") + 686);
  2282.                                           if(┬º┬ºpop())
  2283.                                           {
  2284.                                              set("\x01",eval("\x01") - 400);
  2285.                                           }
  2286.                                           continue;
  2287.                                        }
  2288.                                        if(eval("\x01") == 900)
  2289.                                        {
  2290.                                           set("\x01",eval("\x01") - 400);
  2291.                                           break loop0;
  2292.                                        }
  2293.                                        if(eval("\x01") == 522)
  2294.                                        {
  2295.                                           set("\x01",eval("\x01") + 143);
  2296.                                           ┬º┬ºpush(true);
  2297.                                           continue;
  2298.                                        }
  2299.                                        if(eval("\x01") == 323)
  2300.                                        {
  2301.                                           set("\x01",eval("\x01") + 621);
  2302.                                           ┬º┬ºpush({});
  2303.                                           break loop0;
  2304.                                        }
  2305.                                        if(eval("\x01") == 745)
  2306.                                        {
  2307.                                           set("\x01",eval("\x01") - 173);
  2308.                                           if(┬º┬ºpop())
  2309.                                           {
  2310.                                              set("\x01",eval("\x01") - 50);
  2311.                                           }
  2312.                                           continue;
  2313.                                        }
  2314.                                        if(eval("\x01") == 500)
  2315.                                        {
  2316.                                           set("\x01",eval("\x01") - 322);
  2317.                                           ┬º┬ºpush(true);
  2318.                                           continue;
  2319.                                        }
  2320.                                        if(eval("\x01") == 762)
  2321.                                        {
  2322.                                           set("\x01",eval("\x01") - 312);
  2323.                                           ┬º┬ºpush(true);
  2324.                                           continue;
  2325.                                        }
  2326.                                        if(eval("\x01") == 932)
  2327.                                        {
  2328.                                           set("\x01",eval("\x01") - 860);
  2329.                                           nextFrame();
  2330.                                           stop();
  2331.                                           break loop0;
  2332.                                        }
  2333.                                        if(eval("\x01") == 805)
  2334.                                        {
  2335.                                           set("\x01",eval("\x01") - 302);
  2336.                                           if(┬º┬ºpop())
  2337.                                           {
  2338.                                              set("\x01",eval("\x01") + 259);
  2339.                                           }
  2340.                                           continue;
  2341.                                        }
  2342.                                        if(eval("\x01") == 178)
  2343.                                        {
  2344.                                           set("\x01",eval("\x01") + 145);
  2345.                                           if(┬º┬ºpop())
  2346.                                           {
  2347.                                              set("\x01",eval("\x01") + 621);
  2348.                                           }
  2349.                                           continue;
  2350.                                        }
  2351.                                        if(eval("\x01") == 256)
  2352.                                        {
  2353.                                           set("\x01",eval("\x01") + 173);
  2354.                                           break loop0;
  2355.                                        }
  2356.                                        if(eval("\x01") == 423)
  2357.                                        {
  2358.                                           set("\x01",eval("\x01") - 209);
  2359.                                           ┬º┬ºpush(true);
  2360.                                           continue;
  2361.                                        }
  2362.                                        if(eval("\x01") == 327)
  2363.                                        {
  2364.                                           set("\x01",eval("\x01") + 598);
  2365.                                           if(┬º┬ºpop())
  2366.                                           {
  2367.                                              set("\x01",eval("\x01") - 906);
  2368.                                           }
  2369.                                           continue;
  2370.                                        }
  2371.                                        if(eval("\x01") != 503)
  2372.                                        {
  2373.                                           if(eval("\x01") == 925)
  2374.                                           {
  2375.                                              set("\x01",eval("\x01") - 906);
  2376.                                              ifFrameLoaded(40488)
  2377.                                              {
  2378.                                                 while(true)
  2379.                                                 {
  2380.                                                    if(eval("\x01") == 964)
  2381.                                                    {
  2382.                                                       set("\x01",eval("\x01") - 579);
  2383.                                                       ┬º┬ºpush(true);
  2384.                                                    }
  2385.                                                    else if(eval("\x01") == 473)
  2386.                                                    {
  2387.                                                       set("\x01",eval("\x01") - 289);
  2388.                                                       if(┬º┬ºpop())
  2389.                                                       {
  2390.                                                          set("\x01",eval("\x01") - 62);
  2391.                                                       }
  2392.                                                    }
  2393.                                                    else if(eval("\x01") == 648)
  2394.                                                    {
  2395.                                                       set("\x01",eval("\x01") - 408);
  2396.                                                       if(┬º┬ºpop())
  2397.                                                       {
  2398.                                                          set("\x01",eval("\x01") + 641);
  2399.                                                       }
  2400.                                                    }
  2401.                                                    else if(eval("\x01") == 75)
  2402.                                                    {
  2403.                                                       set("\x01",eval("\x01") + 160);
  2404.                                                       if(┬º┬ºpop())
  2405.                                                       {
  2406.                                                          set("\x01",eval("\x01") + 34);
  2407.                                                       }
  2408.                                                    }
  2409.                                                    else if(eval("\x01") == 914)
  2410.                                                    {
  2411.                                                       set("\x01",eval("\x01") - 839);
  2412.                                                       ┬º┬ºpush(true);
  2413.                                                    }
  2414.                                                    else if(eval("\x01") == 859)
  2415.                                                    {
  2416.                                                       set("\x01",eval("\x01") - 104);
  2417.                                                       if(┬º┬ºpop())
  2418.                                                       {
  2419.                                                          set("\x01",eval("\x01") - 598);
  2420.                                                       }
  2421.                                                    }
  2422.                                                    else
  2423.                                                    {
  2424.                                                       if(eval("\x01") == 686)
  2425.                                                       {
  2426.                                                          set("\x01",eval("\x01") - 85);
  2427.                                                          break;
  2428.                                                       }
  2429.                                                       if(eval("\x01") == 239)
  2430.                                                       {
  2431.                                                          set("\x01",eval("\x01") + 447);
  2432.                                                          if(┬º┬ºpop())
  2433.                                                          {
  2434.                                                             set("\x01",eval("\x01") - 85);
  2435.                                                          }
  2436.                                                       }
  2437.                                                       else if(eval("\x01") == 559)
  2438.                                                       {
  2439.                                                          set("\x01",eval("\x01") + 105);
  2440.                                                          if(┬º┬ºpop())
  2441.                                                          {
  2442.                                                             set("\x01",eval("\x01") - 47);
  2443.                                                          }
  2444.                                                       }
  2445.                                                       else
  2446.                                                       {
  2447.                                                          if(eval("\x01") == 235)
  2448.                                                          {
  2449.                                                             set("\x01",eval("\x01") + 34);
  2450.                                                             break;
  2451.                                                          }
  2452.                                                          if(eval("\x01") == 414)
  2453.                                                          {
  2454.                                                             set("\x01",eval("\x01") - 203);
  2455.                                                             break;
  2456.                                                          }
  2457.                                                          if(eval("\x01") == 385)
  2458.                                                          {
  2459.                                                             set("\x01",eval("\x01") - 71);
  2460.                                                             if(┬º┬ºpop())
  2461.                                                             {
  2462.                                                                set("\x01",eval("\x01") - 302);
  2463.                                                             }
  2464.                                                          }
  2465.                                                          else
  2466.                                                          {
  2467.                                                             if(eval("\x01") == 314)
  2468.                                                             {
  2469.                                                                set("\x01",eval("\x01") - 302);
  2470.                                                                break;
  2471.                                                             }
  2472.                                                             if(eval("\x01") == 881)
  2473.                                                             {
  2474.                                                                set("\x01",eval("\x01") - 22);
  2475.                                                                ┬º┬ºpush(true);
  2476.                                                             }
  2477.                                                             else
  2478.                                                             {
  2479.                                                                if(eval("\x01") == 664)
  2480.                                                                {
  2481.                                                                   set("\x01",eval("\x01") - 47);
  2482.                                                                   ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop() === ┬º┬ºpop()]());
  2483.                                                                   break;
  2484.                                                                }
  2485.                                                                if(eval("\x01") == 12)
  2486.                                                                {
  2487.                                                                   set("\x01",eval("\x01") + 636);
  2488.                                                                   ┬º┬ºpush(true);
  2489.                                                                }
  2490.                                                                else
  2491.                                                                {
  2492.                                                                   if(eval("\x01") == 240)
  2493.                                                                   {
  2494.                                                                      set("\x01",eval("\x01") + 641);
  2495.                                                                      ┬º┬ºpush(delete ┬º┬ºpop());
  2496.                                                                      break;
  2497.                                                                   }
  2498.                                                                   if(eval("\x01") == 617)
  2499.                                                                   {
  2500.                                                                      set("\x01",eval("\x01") - 144);
  2501.                                                                      ┬º┬ºpush(true);
  2502.                                                                   }
  2503.                                                                   else
  2504.                                                                   {
  2505.                                                                      if(eval("\x01") == 406)
  2506.                                                                      {
  2507.                                                                         set("\x01",eval("\x01") + 508);
  2508.                                                                         getUrl("∩┐╜p\x01\x01", "");
  2509.                                                                         break;
  2510.                                                                      }
  2511.                                                                      if(eval("\x01") == 25)
  2512.                                                                      {
  2513.                                                                         set("\x01",eval("\x01") + 381);
  2514.                                                                         if(┬º┬ºpop())
  2515.                                                                         {
  2516.                                                                            set("\x01",eval("\x01") + 508);
  2517.                                                                         }
  2518.                                                                      }
  2519.                                                                      else
  2520.                                                                      {
  2521.                                                                         if(eval("\x01") == 184)
  2522.                                                                         {
  2523.                                                                            set("\x01",eval("\x01") - 62);
  2524.                                                                            ┬º┬ºpop();
  2525.                                                                            break;
  2526.                                                                         }
  2527.                                                                         if(eval("\x01") == 269)
  2528.                                                                         {
  2529.                                                                            set("\x01",eval("\x01") - 47);
  2530.                                                                            ┬º┬ºpush(true);
  2531.                                                                         }
  2532.                                                                         else if(eval("\x01") == 122)
  2533.                                                                         {
  2534.                                                                            set("\x01",eval("\x01") - 97);
  2535.                                                                            ┬º┬ºpush(true);
  2536.                                                                         }
  2537.                                                                         else if(eval("\x01") == 885)
  2538.                                                                         {
  2539.                                                                            set("\x01",eval("\x01") - 646);
  2540.                                                                            ┬º┬ºpush(true);
  2541.                                                                         }
  2542.                                                                         else if(eval("\x01") == 222)
  2543.                                                                         {
  2544.                                                                            set("\x01",eval("\x01") - 22);
  2545.                                                                            if(┬º┬ºpop())
  2546.                                                                            {
  2547.                                                                               set("\x01",eval("\x01") + 685);
  2548.                                                                            }
  2549.                                                                         }
  2550.                                                                         else if(eval("\x01") == 367)
  2551.                                                                         {
  2552.                                                                            set("\x01",eval("\x01") + 47);
  2553.                                                                            if(┬º┬ºpop())
  2554.                                                                            {
  2555.                                                                               set("\x01",eval("\x01") - 203);
  2556.                                                                            }
  2557.                                                                         }
  2558.                                                                         else
  2559.                                                                         {
  2560.                                                                            if(eval("\x01") == 755)
  2561.                                                                            {
  2562.                                                                               set("\x01",eval("\x01") - 598);
  2563.                                                                               break;
  2564.                                                                            }
  2565.                                                                            if(eval("\x01") == 211)
  2566.                                                                            {
  2567.                                                                               set("\x01",eval("\x01") + 432);
  2568.                                                                               stop();
  2569.                                                                               System.security.allowDomain("*.*","*","*.*.*");
  2570.                                                                               this.flashBtn._visible = false;
  2571.                                                                               var st = System.capabilities.version;
  2572.                                                                               var ver = st.substring(st.indexOf(" "),st.indexOf(","));
  2573.                                                                               if(ver < 8)
  2574.                                                                               {
  2575.                                                                                  trace("VER " + ver);
  2576.                                                                                  this.flashBtn._visible = true;
  2577.                                                                                  preloader.unloadMovie();
  2578.                                                                                  gotoAndStop(1);
  2579.                                                                               }
  2580.                                                                               System.security.allowDomain("gamezhero.com","files.gamezhero.com");
  2581.                                                                               if(!_root.gamezhero)
  2582.                                                                               {
  2583.                                                                                  System.security.allowDomain("gamezhero.com","files.gamezhero.com");
  2584.                                                                                  _root.createEmptyMovieClip("gamezhero",100000);
  2585.                                                                                  _root.gamezhero.loadMovie("http://files.gamezhero.com/flash/gamezhero2.swf?x=-100&y=-100&from=hrc&scale=80&t=1145553527687");
  2586.                                                                               }
  2587.                                                                               break;
  2588.                                                                            }
  2589.                                                                            if(eval("\x01") == 200)
  2590.                                                                            {
  2591.                                                                               set("\x01",eval("\x01") + 685);
  2592.                                                                               ┬º┬ºpop();
  2593.                                                                               if(_loc1_[┬º┬ºconstant(28)][┬º┬ºconstant(77)]() < 0.001)
  2594.                                                                               {
  2595.                                                                                  _loc1_[┬º┬ºconstant(28)] = new flashBtn._visible(0,0);
  2596.                                                                               }
  2597.                                                                               if(_loc1_[┬º┬ºconstant(27)][┬º┬ºconstant(77)]() < 0.001)
  2598.                                                                               {
  2599.                                                                                  _loc1_[┬º┬ºconstant(27)] = new flashBtn._visible(0,0);
  2600.                                                                               }
  2601.                                                                               _loc1_[┬º┬ºconstant(104)]();
  2602.                                                                               if(_loc1_[┬º┬ºconstant(33)])
  2603.                                                                               {
  2604.                                                                                  _loc4_ = _loc2_[┬º┬ºconstant(65)][┬º┬ºconstant(66)][┬º┬ºconstant(105)] * 0.5 * _loc1_.createEmptyMovieClip / _loc1_[" "];
  2605.                                                                                  _loc1_[┬º┬ºconstant(36)][┬º┬ºconstant(41)][┬º┬ºconstant(44)](_loc4_);
  2606.                                                                                  _loc1_[┬º┬ºconstant(36)][┬º┬ºconstant(37)][┬º┬ºconstant(44)](_loc2_[┬º┬ºconstant(65)][┬º┬ºconstant(66)][┬º┬ºconstant(105)]);
  2607.                                                                               }
  2608.                                                                               ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  2609.                                                                               _loc2_[┬º┬ºconstant(106)] = function(N, t, auto)
  2610.                                                                               {
  2611.                                                                                  var _loc8_ = 1.01;
  2612.                                                                                  var _loc10_ = new flashBtn._visible(N[┬º┬ºconstant(53)] * t * _loc8_,N[┬º┬ºconstant(50)] * t * _loc8_);
  2613.                                                                                  this.st[┬º┬ºconstant(91)](_loc10_);
  2614.                                                                                  var _loc5_ = auto.st[┬º┬ºconstant(51)][┬º┬ºconstant(53)] - this.st[┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  2615.                                                                                  var _loc4_ = auto._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(50)] - this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  2616.                                                                                  var _loc7_ = eval(┬º┬ºconstant(58))[┬º┬ºconstant(74)](eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc5_),eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc4_));
  2617.                                                                                  _loc5_ /= _loc7_;
  2618.                                                                                  _loc4_ /= _loc7_;
  2619.                                                                                  var _loc9_ = new Vector.poly(_loc5_,_loc4_);
  2620.                                                                                  var _loc6_ = this.getRotation[┬º┬ºconstant(77)]() + auto.getRotation[┬º┬ºconstant(77)]();
  2621.                                                                                  _loc7_ = this.getX + auto.getX;
  2622.                                                                                  var _loc12_ = _loc9_[┬º┬ºconstant(75)](_loc6_ * (this.getX / _loc7_) * 0.5)[┬º┬ºconstant(107)](180);
  2623.                                                                                  var _loc11_ = _loc9_[┬º┬ºconstant(75)](_loc6_ * (auto.getX / _loc7_) * 0.5);
  2624.                                                                                  _root[┬º┬ºconstant(39)][┬º┬ºconstant(40)](┬º┬ºconstant(108),0,false,_loc6_ / 2 / this.gameEngine);
  2625.                                                                                  this[┬º┬ºconstant(109)](_loc12_);
  2626.                                                                                  auto[┬º┬ºconstant(109)](_loc11_);
  2627.                                                                               };
  2628.                                                                               _loc2_[┬º┬ºconstant(110)] = function(N, t, obj)
  2629.                                                                               {
  2630.                                                                                  var _loc6_ = 1.01;
  2631.                                                                                  var _loc7_ = new Vector.poly(N[┬º┬ºconstant(53)] * t * _loc6_,N[┬º┬ºconstant(50)] * t * _loc6_);
  2632.                                                                                  this._rotation[┬º┬ºconstant(91)](_loc7_);
  2633.                                                                                  var _loc4_ = obj._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(53)] - this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  2634.                                                                                  var _loc3_ = obj._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(50)] - this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  2635.                                                                                  var _loc9_ = eval(┬º┬ºconstant(58))[┬º┬ºconstant(74)](eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc4_),eval(┬º┬ºconstant(58))[┬º┬ºconstant(73)](_loc3_));
  2636.                                                                                  _loc4_ /= _loc9_;
  2637.                                                                                  _loc3_ /= _loc9_;
  2638.                                                                                  var _loc10_ = new Vector.poly(_loc4_,_loc3_);
  2639.                                                                                  var _loc5_ = this.getRotation[┬º┬ºconstant(77)]();
  2640.                                                                                  _loc9_ = this.getX + obj.getX;
  2641.                                                                                  var _loc11_ = _loc10_[┬º┬ºconstant(75)](_loc5_ * (this.getX / _loc9_))[┬º┬ºconstant(107)](180);
  2642.                                                                                  _root[┬º┬ºconstant(39)][┬º┬ºconstant(40)](┬º┬ºconstant(108),0,false,_loc5_ / 2 / this.gameEngine);
  2643.                                                                                  this[┬º┬ºconstant(109)](_loc11_);
  2644.                                                                               };
  2645.                                                                               _loc2_[┬º┬ºconstant(111)] = function()
  2646.                                                                               {
  2647.                                                                                  return this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(54)]();
  2648.                                                                               };
  2649.                                                                               _loc2_[┬º┬ºconstant(112)] = function()
  2650.                                                                               {
  2651.                                                                                  return this._rotation[┬º┬ºconstant(51)][┬º┬ºconstant(52)]();
  2652.                                                                               };
  2653.                                                                               _loc2_[┬º┬ºconstant(113)] = function()
  2654.                                                                               {
  2655.                                                                                  return this.mass;
  2656.                                                                               };
  2657.                                                                               _loc2_[┬º┬ºconstant(109)] = function(V)
  2658.                                                                               {
  2659.                                                                                  this.__get__y[┬º┬ºconstant(78)](V);
  2660.                                                                               };
  2661.                                                                               _loc2_[┬º┬ºconstant(114)] = function(g)
  2662.                                                                               {
  2663.                                                                                  this.update[┬º┬ºconstant(115)](g);
  2664.                                                                               };
  2665.                                                                               _loc2_[┬º┬ºconstant(104)] = function()
  2666.                                                                               {
  2667.                                                                                  this._rotation[┬º┬ºconstant(116)]();
  2668.                                                                                  for(var _loc2_ in this.update)
  2669.                                                                                  {
  2670.                                                                                     this.update[_loc2_][┬º┬ºconstant(80)][┬º┬ºconstant(117)](this.update[_loc2_],this);
  2671.                                                                                  }
  2672.                                                                               };
  2673.                                                                               _loc2_[┬º┬ºconstant(118)] = function(code1, code2, code3, code4)
  2674.                                                                               {
  2675.                                                                                  this[┬º┬ºconstant(85)] = new _parent();
  2676.                                                                                  var _loc3_ = 0;
  2677.                                                                                  while(_loc3_ < arguments[┬º┬ºconstant(119)])
  2678.                                                                                  {
  2679.                                                                                     this[┬º┬ºconstant(85)][┬º┬ºconstant(115)](arguments[_loc3_]);
  2680.                                                                                     _loc3_ = _loc3_ + 1;
  2681.                                                                                  }
  2682.                                                                                  this.updateObject = true;
  2683.                                                                               };
  2684.                                                                               _loc2_[┬º┬ºconstant(120)] = function(kof)
  2685.                                                                               {
  2686.                                                                                  this.prototype = kof;
  2687.                                                                                  this.updateObject = false;
  2688.                                                                               };
  2689.                                                                               _loc2_[┬º┬ºconstant(121)] = function(p1, p2)
  2690.                                                                               {
  2691.                                                                                  this[┬º┬ºconstant(122)] = p1;
  2692.                                                                                  this[┬º┬ºconstant(123)] = p2;
  2693.                                                                               };
  2694.                                                                               _loc2_[┬º┬ºconstant(124)] = function()
  2695.                                                                               {
  2696.                                                                                  this[┬º┬ºconstant(69)] = this.getY;
  2697.                                                                                  if(this.updateObject)
  2698.                                                                                  {
  2699.                                                                                     this.ASSetPropFlags = this[┬º┬ºconstant(84)];
  2700.                                                                                  }
  2701.                                                                                  else
  2702.                                                                                  {
  2703.                                                                                     this.ASSetPropFlags = this[┬º┬ºconstant(72)];
  2704.                                                                                  }
  2705.                                                                               };
  2706.                                                                               ┬º┬ºconstant(125)(engine.Obj[┬º┬ºconstant(45)],null,1);
  2707.                                                                               break;
  2708.                                                                            }
  2709.                                                                            if(eval("\x01") == 157)
  2710.                                                                            {
  2711.                                                                               set("\x01",eval("\x01") + 402);
  2712.                                                                               ┬º┬ºpush(true);
  2713.                                                                            }
  2714.                                                                            else
  2715.                                                                            {
  2716.                                                                               if(eval("\x01") != 601)
  2717.                                                                               {
  2718.                                                                                  break;
  2719.                                                                               }
  2720.                                                                               set("\x01",eval("\x01") - 234);
  2721.                                                                               ┬º┬ºpush(true);
  2722.                                                                            }
  2723.                                                                         }
  2724.                                                                      }
  2725.                                                                   }
  2726.                                                                }
  2727.                                                             }
  2728.                                                          }
  2729.                                                       }
  2730.                                                    }
  2731.                                                 }
  2732.                                              }
  2733.                                           }
  2734.                                           if(eval("\x01") == 72)
  2735.                                           {
  2736.                                              set("\x01",eval("\x01") + 340);
  2737.                                              delete this.onEnterFrame;
  2738.                                              this.removeMovieClip();
  2739.                                              break loop0;
  2740.                                           }
  2741.                                           if(eval("\x01") == 19)
  2742.                                           {
  2743.                                              set("\x01",eval("\x01") + 726);
  2744.                                              ┬º┬ºpush(true);
  2745.                                           }
  2746.                                           else if(eval("\x01") == 665)
  2747.                                           {
  2748.                                              set("\x01",eval("\x01") - 409);
  2749.                                              if(┬º┬ºpop())
  2750.                                              {
  2751.                                                 set("\x01",eval("\x01") + 173);
  2752.                                              }
  2753.                                           }
  2754.                                           else
  2755.                                           {
  2756.                                              if(eval("\x01") != 429)
  2757.                                              {
  2758.                                                 break loop0;
  2759.                                              }
  2760.                                              set("\x01",eval("\x01") + 376);
  2761.                                              ┬º┬ºpush(true);
  2762.                                           }
  2763.                                           continue;
  2764.                                        }
  2765.                                        set("\x01",eval("\x01") + 259);
  2766.                                        ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  2767.                                        while(true)
  2768.                                        {
  2769.                                           set(┬º┬ºpop(),┬º┬ºpop());
  2770.                                           if(┬º┬ºpop())
  2771.                                           {
  2772.                                              set("\x01",eval("\x01") + 34);
  2773.                                           }
  2774.                                        }
  2775.                                        addr628:
  2776.                                        while(true)
  2777.                                        {
  2778.                                           if(eval("\x01") == 964)
  2779.                                           {
  2780.                                              set("\x01",eval("\x01") - 579);
  2781.                                              ┬º┬ºpush(true);
  2782.                                              continue;
  2783.                                           }
  2784.                                           if(eval("\x01") == 473)
  2785.                                           {
  2786.                                              set("\x01",eval("\x01") - 289);
  2787.                                              if(┬º┬ºpop())
  2788.                                              {
  2789.                                                 set("\x01",eval("\x01") - 62);
  2790.                                              }
  2791.                                              continue;
  2792.                                           }
  2793.                                           if(eval("\x01") == 648)
  2794.                                           {
  2795.                                              set("\x01",eval("\x01") - 408);
  2796.                                              if(┬º┬ºpop())
  2797.                                              {
  2798.                                                 set("\x01",eval("\x01") + 641);
  2799.                                              }
  2800.                                              continue;
  2801.                                           }
  2802.                                           if(eval("\x01") == 75)
  2803.                                           {
  2804.                                              ┬º┬ºgoto(addr628);
  2805.                                              ┬º┬ºpush("\x01");
  2806.                                              ┬º┬ºpush(eval("\x01") + 160);
  2807.                                           }
  2808.                                           else
  2809.                                           {
  2810.                                              if(eval("\x01") == 914)
  2811.                                              {
  2812.                                                 set("\x01",eval("\x01") - 839);
  2813.                                                 ┬º┬ºpush(true);
  2814.                                                 continue;
  2815.                                              }
  2816.                                              if(eval("\x01") == 859)
  2817.                                              {
  2818.                                                 set("\x01",eval("\x01") - 104);
  2819.                                                 if(┬º┬ºpop())
  2820.                                                 {
  2821.                                                    set("\x01",eval("\x01") - 598);
  2822.                                                 }
  2823.                                                 continue;
  2824.                                              }
  2825.                                              if(eval("\x01") == 686)
  2826.                                              {
  2827.                                                 set("\x01",eval("\x01") - 85);
  2828.                                                 break loop0;
  2829.                                              }
  2830.                                              if(eval("\x01") == 239)
  2831.                                              {
  2832.                                                 set("\x01",eval("\x01") + 447);
  2833.                                                 if(┬º┬ºpop())
  2834.                                                 {
  2835.                                                    set("\x01",eval("\x01") - 85);
  2836.                                                 }
  2837.                                                 continue;
  2838.                                              }
  2839.                                              if(eval("\x01") == 559)
  2840.                                              {
  2841.                                                 set("\x01",eval("\x01") + 105);
  2842.                                                 if(┬º┬ºpop())
  2843.                                                 {
  2844.                                                    set("\x01",eval("\x01") - 47);
  2845.                                                 }
  2846.                                                 continue;
  2847.                                              }
  2848.                                              if(eval("\x01") == 235)
  2849.                                              {
  2850.                                                 set("\x01",eval("\x01") + 34);
  2851.                                                 break loop0;
  2852.                                              }
  2853.                                              if(eval("\x01") == 414)
  2854.                                              {
  2855.                                                 set("\x01",eval("\x01") - 203);
  2856.                                                 break loop0;
  2857.                                              }
  2858.                                              if(eval("\x01") == 385)
  2859.                                              {
  2860.                                                 set("\x01",eval("\x01") - 71);
  2861.                                                 if(┬º┬ºpop())
  2862.                                                 {
  2863.                                                    set("\x01",eval("\x01") - 302);
  2864.                                                 }
  2865.                                                 continue;
  2866.                                              }
  2867.                                              if(eval("\x01") == 314)
  2868.                                              {
  2869.                                                 set("\x01",eval("\x01") - 302);
  2870.                                                 break loop0;
  2871.                                              }
  2872.                                              if(eval("\x01") == 881)
  2873.                                              {
  2874.                                                 set("\x01",eval("\x01") - 22);
  2875.                                                 ┬º┬ºpush(true);
  2876.                                                 continue;
  2877.                                              }
  2878.                                              if(eval("\x01") == 664)
  2879.                                              {
  2880.                                                 set("\x01",eval("\x01") - 47);
  2881.                                                 ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop() === ┬º┬ºpop()]());
  2882.                                                 break loop0;
  2883.                                              }
  2884.                                              if(eval("\x01") == 12)
  2885.                                              {
  2886.                                                 set("\x01",eval("\x01") + 636);
  2887.                                                 ┬º┬ºpush(true);
  2888.                                                 continue;
  2889.                                              }
  2890.                                              if(eval("\x01") == 240)
  2891.                                              {
  2892.                                                 set("\x01",eval("\x01") + 641);
  2893.                                                 ┬º┬ºpush(delete ┬º┬ºpop());
  2894.                                                 break loop0;
  2895.                                              }
  2896.                                              if(eval("\x01") == 617)
  2897.                                              {
  2898.                                                 set("\x01",eval("\x01") - 144);
  2899.                                                 ┬º┬ºpush(true);
  2900.                                                 continue;
  2901.                                              }
  2902.                                              if(eval("\x01") == 406)
  2903.                                              {
  2904.                                                 set("\x01",eval("\x01") + 508);
  2905.                                                 getUrl("∩┐╜p\x01\x01", "");
  2906.                                                 break loop0;
  2907.                                              }
  2908.                                              if(eval("\x01") == 25)
  2909.                                              {
  2910.                                                 set("\x01",eval("\x01") + 381);
  2911.                                                 if(┬º┬ºpop())
  2912.                                                 {
  2913.                                                    set("\x01",eval("\x01") + 508);
  2914.                                                 }
  2915.                                                 continue;
  2916.                                              }
  2917.                                              if(eval("\x01") == 184)
  2918.                                              {
  2919.                                                 set("\x01",eval("\x01") - 62);
  2920.                                                 ┬º┬ºpop();
  2921.                                                 break loop0;
  2922.                                              }
  2923.                                              if(eval("\x01") == 269)
  2924.                                              {
  2925.                                                 set("\x01",eval("\x01") - 47);
  2926.                                                 ┬º┬ºpush(true);
  2927.                                                 continue;
  2928.                                              }
  2929.                                              if(eval("\x01") == 122)
  2930.                                              {
  2931.                                                 set("\x01",eval("\x01") - 97);
  2932.                                                 ┬º┬ºpush(true);
  2933.                                                 continue;
  2934.                                              }
  2935.                                              if(eval("\x01") == 885)
  2936.                                              {
  2937.                                                 set("\x01",eval("\x01") - 646);
  2938.                                                 ┬º┬ºpush(true);
  2939.                                                 continue;
  2940.                                              }
  2941.                                              if(eval("\x01") == 222)
  2942.                                              {
  2943.                                                 set("\x01",eval("\x01") - 22);
  2944.                                                 if(┬º┬ºpop())
  2945.                                                 {
  2946.                                                    set("\x01",eval("\x01") + 685);
  2947.                                                 }
  2948.                                                 continue;
  2949.                                              }
  2950.                                              if(eval("\x01") == 367)
  2951.                                              {
  2952.                                                 set("\x01",eval("\x01") + 47);
  2953.                                                 if(┬º┬ºpop())
  2954.                                                 {
  2955.                                                    set("\x01",eval("\x01") - 203);
  2956.                                                 }
  2957.                                                 continue;
  2958.                                              }
  2959.                                              if(eval("\x01") == 755)
  2960.                                              {
  2961.                                                 set("\x01",eval("\x01") - 598);
  2962.                                                 break loop0;
  2963.                                              }
  2964.                                              if(eval("\x01") == 211)
  2965.                                              {
  2966.                                                 set("\x01",eval("\x01") + 432);
  2967.                                                 stop();
  2968.                                                 System.security.allowDomain("*.*","*","*.*.*");
  2969.                                                 this.flashBtn._visible = false;
  2970.                                                 var st = System.capabilities.version;
  2971.                                                 var ver = st.substring(st.indexOf(" "),st.indexOf(","));
  2972.                                                 if(ver < 8)
  2973.                                                 {
  2974.                                                    trace("VER " + ver);
  2975.                                                    this.flashBtn._visible = true;
  2976.                                                    preloader.unloadMovie();
  2977.                                                    gotoAndStop(1);
  2978.                                                 }
  2979.                                                 System.security.allowDomain("gamezhero.com","files.gamezhero.com");
  2980.                                                 if(!_root.gamezhero)
  2981.                                                 {
  2982.                                                    System.security.allowDomain("gamezhero.com","files.gamezhero.com");
  2983.                                                    _root.createEmptyMovieClip("gamezhero",100000);
  2984.                                                    _root.gamezhero.loadMovie("http://files.gamezhero.com/flash/gamezhero2.swf?x=-100&y=-100&from=hrc&scale=80&t=1145553527687");
  2985.                                                 }
  2986.                                                 break loop0;
  2987.                                              }
  2988.                                              if(eval("\x01") != 200)
  2989.                                              {
  2990.                                                 if(eval("\x01") == 157)
  2991.                                                 {
  2992.                                                    set("\x01",eval("\x01") + 402);
  2993.                                                    ┬º┬ºpush(true);
  2994.                                                 }
  2995.                                                 else
  2996.                                                 {
  2997.                                                    if(eval("\x01") != 601)
  2998.                                                    {
  2999.                                                       break loop0;
  3000.                                                    }
  3001.                                                    set("\x01",eval("\x01") - 234);
  3002.                                                    ┬º┬ºpush(true);
  3003.                                                 }
  3004.                                                 continue;
  3005.                                              }
  3006.                                              set("\x01",eval("\x01") + 685);
  3007.                                              ┬º┬ºpop();
  3008.                                              if(_loc1_[┬º┬ºconstant(28)][┬º┬ºconstant(77)]() < 0.001)
  3009.                                              {
  3010.                                                 _loc1_[┬º┬ºconstant(28)] = new flashBtn._visible(0,0);
  3011.                                              }
  3012.                                              if(_loc1_[┬º┬ºconstant(27)][┬º┬ºconstant(77)]() < 0.001)
  3013.                                              {
  3014.                                                 _loc1_[┬º┬ºconstant(27)] = new flashBtn._visible(0,0);
  3015.                                              }
  3016.                                              _loc1_[┬º┬ºconstant(104)]();
  3017.                                              if(_loc1_[┬º┬ºconstant(33)])
  3018.                                              {
  3019.                                                 _loc4_ = _loc2_[┬º┬ºconstant(65)][┬º┬ºconstant(66)][┬º┬ºconstant(105)] * 0.5 * _loc1_.createEmptyMovieClip / _loc1_[" "];
  3020.                                                 _loc1_[┬º┬ºconstant(36)][┬º┬ºconstant(41)][┬º┬ºconstant(44)](_loc4_);
  3021.                                                 _loc1_[┬º┬ºconstant(36)][┬º┬ºconstant(37)][┬º┬ºconstant(44)](_loc2_[┬º┬ºconstant(65)][┬º┬ºconstant(66)][┬º┬ºconstant(105)]);
  3022.                                              }
  3023.                                              ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  3024.                                              ┬º┬ºpush(_loc2_);
  3025.                                              ┬º┬ºpush(┬º┬ºconstant(106));
  3026.                                           }
  3027.                                        }
  3028.                                     }
  3029.                                  }
  3030.                               }
  3031.                            }
  3032.                         }
  3033.                      }
  3034.                      ┬º┬ºgoto(addr6033);
  3035.                   }
  3036.                   ┬º┬ºgoto(addr2513);
  3037.                }
  3038.             }
  3039.          }
  3040.          ┬º┬ºgoto(addr2513);
  3041.       }
  3042.    }
  3043.    set("\x01",eval("\x01") + 739);
  3044.    ┬º┬ºgoto(addr3283);
  3045. }
  3046.